diff --git a/.gitignore b/.gitignore
index ca5461a..744bd6c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,3 +12,4 @@ site/
 # Config builder app
 app/node_modules/
 app/dist/
+app/.vite/
diff --git a/.scripts/X2ModBuildCommon/build_common.ps1 b/.scripts/X2ModBuildCommon/build_common.ps1
index e1f4c44..6316fa9 100644
--- a/.scripts/X2ModBuildCommon/build_common.ps1
+++ b/.scripts/X2ModBuildCommon/build_common.ps1
@@ -238,7 +238,7 @@ class BuildProject {
 		# the mod's packages
 		$modSrcPath = "$($this.modSrcRoot)/Src"
 		if (Test-Path $modSrcPath) {
-			$this.modScriptPackages = @(Get-ChildItem "$($this.modSrcRoot)/Src" -Directory)
+			$this.modScriptPackages = @(Get-ChildItem "$($this.modSrcRoot)/Src" -Directory | Select-Object -ExpandProperty Name)
 		} else {
 			# No scripts to compile
 			$this.modScriptPackages = @()
diff --git a/.scripts/build.ps1 b/.scripts/build.ps1
index 964ed3f..c5a648c 100644
--- a/.scripts/build.ps1
+++ b/.scripts/build.ps1
@@ -12,6 +12,8 @@ Write-Host "Sourcing $common"
 
 $builder = [BuildProject]::new("AbilityEditor", $srcDirectory, $sdkPath, $gamePath)
 
+$builder.IncludeSrc((Join-Path $srcDirectory "SdkOverlay"))
+
 switch ($config)
 {
     "debug" {
diff --git a/.scripts/generate-docs.ps1 b/.scripts/generate-docs.ps1
index d5cd0bb..8680b2f 100644
--- a/.scripts/generate-docs.ps1
+++ b/.scripts/generate-docs.ps1
@@ -156,7 +156,9 @@ function Get-EditAction {
             $gameField = $null
             for ($j = $i + 1; $j -lt [Math]::Min($i + 20, $BodyLines.Count); $j++) {
                 $inner = $BodyLines[$j]
-                if ($inner -match ('^\s*([\w\.\[\]]+)\s*=\s*' + [regex]::Escape($guardVar) + '\.' + [regex]::Escape($field) + '\s*;')) {
+                # plain assignment, or a class reference loaded from the config string:
+                # Target.Foo = class<X>(DynamicLoadObject(Edit.Foo, class'Class'));
+                if ($inner -match ('^\s*([\w\.\[\]]+)\s*=\s*(?:class<[\w\.]+>\(DynamicLoadObject\()?' + [regex]::Escape($guardVar) + '\.' + [regex]::Escape($field) + '\s*(?:;|,\s*class''Class''\)\);)')) {
                     $gameField = Get-GameFieldFromTarget $Matches[1]
                     break
                 }
@@ -167,8 +169,8 @@ function Get-EditAction {
             continue
         }
 
-        # ApplyNameArrayEdit(..., Template.Foo, Edit.Foo, Edit.FooMode, ...)
-        if ($line -match 'Apply(Name|EffectReason)ArrayEdit\s*\(') {
+        # Apply<Type>ArrayEdit(..., Template.Foo, Edit.Foo, Edit.FooMode, ...) - name, string and keyed-struct arrays alike
+        if ($line -match 'Apply\w+ArrayEdit\s*\(') {
             $callArgs = [System.Collections.Generic.List[string]]::new()
             for ($j = $i + 1; $j -lt [Math]::Min($i + 10, $BodyLines.Count); $j++) {
                 $arg = $BodyLines[$j].Trim().TrimEnd(',')
@@ -268,6 +270,9 @@ $Curated = @{
         'EffectEdit.Class'                 = 'Effect class to target/instantiate, e.g. `X2Effect_ApplyWeaponDamage`. Bare names are auto-prefixed with `XComGame.`; empty falls back to `X2Effect`.'
         'EffectEdit.Slot'                  = 'Which effect array to edit (`EAbilityEffectSlot`): `eAES_Target`, `eAES_MultiTarget` or `eAES_Shooter`.'
         'EffectEdit.Mode'                  = 'Per-entry edit mode (`EArrayEditMode`). Defaults to the enum''s first value, which clears the existing array.'
+        'EffectEdit.ApplyOnTickClass'      = 'Redirects this entry at an effect nested in the parent''s `ApplyOnTick` list, so every other field below applies to that child instead. Only `X2Effect_Persistent` and its subclasses have one. Use it to reach the damage of a damage-over-time effect: the `X2Effect_Burning` object itself only carries duration, while the per-tick damage lives in an `X2Effect_ApplyWeaponDamage` beneath it. Bare names are auto-prefixed with `XComGame.`.'
+        'EffectEdit.ApplyOnTickIndex'      = 'Which matching child to edit when several in `ApplyOnTick` share the same class. Counts only matches of `ApplyOnTickClass`, so 0 is the first one. Default 0.'
+        'EffectEdit.ApplyOnTickMode'       = 'What to do when `ApplyOnTickClass` is not already in the list (`EArrayEditMode`): `eAEM_Merge`/`eAEM_AddOnly` append one, `eAEM_Remove` removes it, `eAEM_ReplaceAll` clears the list first. Ignored when `ApplyOnTickClass` is empty.'
         'ConditionEdit.Class'              = 'Condition class to target/instantiate, e.g. `X2Condition_UnitProperty`. Bare names are auto-prefixed with `XComGame.`.'
         'ConditionEdit.Mode'               = 'Per-entry edit mode (`EArrayEditMode`). Defaults to the enum''s first value, which clears the existing array.'
         'AdditionalCooldownEdit.AbilityName'   = 'Ability whose cooldown entry is added/updated in `AditionalAbilityCooldowns`.'
@@ -463,14 +468,37 @@ foreach ($structName in $StructOrder) {
 $dlcLines = Read-TextFile $DlcInfoFile
 $dlcText = $dlcLines -join "`n"
 
+$Warnings = [System.Collections.Generic.List[string]]::new()
+
 $Registries = @{}
-foreach ($m in [regex]::Matches($dlcText, "(?m)^\s*(\w+Editors)\((\d+)\)\s*=\s*class'(\w+)'")) {
+$registryPattern = "(?m)^\s*(\w+Editors)(?:\((\d+)\)\s*=|\.Add\()\s*class'(\w+)'"
+
+$ordinal = 0
+foreach ($m in [regex]::Matches($dlcText, $registryPattern)) {
     $reg = $m.Groups[1].Value
     if (-not $Registries.ContainsKey($reg)) { $Registries[$reg] = [System.Collections.Generic.List[object]]::new() }
-    $Registries[$reg].Add(@{ Index = [int]$m.Groups[2].Value; Class = $m.Groups[3].Value })
+
+    $indexed = $m.Groups[2].Success
+    $Registries[$reg].Add(@{
+        Indexed  = $indexed
+        Index    = if ($indexed) { [int]$m.Groups[2].Value } else { $ordinal }
+        Ordinal  = $ordinal
+        Class    = $m.Groups[3].Value
+    })
+    $ordinal++
 }
+
 foreach ($reg in @($Registries.Keys)) {
-    $Registries[$reg] = @($Registries[$reg] | Sort-Object { $_.Index } | ForEach-Object { $_.Class })
+    $entries = $Registries[$reg]
+    $indexedCount = @($entries | Where-Object { $_.Indexed }).Count
+
+    if ($indexedCount -gt 0 -and $indexedCount -lt $entries.Count) {
+        $Warnings.Add("Registry $reg mixes Foo(n) = class'...' with Foo.Add(class'...'). Dispatch order follows the numbered entries first, which is unlikely to be what the file reads as.")
+    }
+
+    # Sorting by Index then Ordinal keeps appends in source order, since every append
+    # shares the running ordinal as its index.
+    $Registries[$reg] = @($entries | Sort-Object { $_.Index }, { $_.Ordinal } | ForEach-Object { $_.Class })
 }
 
 $dlcBlocks = Get-FunctionBlockMap $dlcLines
@@ -591,7 +619,6 @@ function Get-DefinerChain {
     return $result.ToArray()
 }
 
-$Warnings = [System.Collections.Generic.List[string]]::new()
 $FamilyModels = [System.Collections.Generic.List[object]]::new()
 
 foreach ($fam in $Curated.Families) {
@@ -789,8 +816,8 @@ function Get-SdkClassInfo {
             elseif ($rest -match '^(transient|duplicatetransient)\b')           { $reason = 'transient' }
             elseif ($rest -match 'delegate<')                                   { $reason = 'delegate &mdash; code-only' }
 
-            # strip neutral modifiers to reach the type token
-            $declaration = $rest -replace '^(init|instanced|editinline\w*|noimport|repnotify|const|editconst|native(\(\w+\))?)\s+', ''
+            # strip every leading modifier (the reason is already recorded) to reach the type token
+            $declaration = $rest -replace '^((config|globalconfig|localized|private|privatewrite|protected|protectedwrite|deprecated|transient|duplicatetransient|init|instanced|editinline\w*|noimport|repnotify|const|editconst|native(\(\w+\))?)\s+)+', ''
             if ($declaration -notmatch '^(array<\s*[\w\.]+\s*>|class(<[\w\.]+>)?|[\w\.<>]+)\s+(\w+(?:\s*,\s*\w+)*)\s*[;\[]') { continue }
 
             $typeTok = $Matches[1]
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/AE_DataStructures.uc b/AbilityEditor/Src/AbilityEditor/Classes/AE_DataStructures.uc
index 7b7e53d..6edce25 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/AE_DataStructures.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/AE_DataStructures.uc
@@ -54,6 +54,7 @@ struct AdditionalCooldownEdit
 	var name AbilityName;
 
 	var bool SetNumTurns;
+	// Cooldown applied to that other ability, in turns.
 	var int NumTurns;
 
 	var bool SetUseAbilityCooldownNumTurns;
@@ -77,63 +78,84 @@ struct CostEdit
 
 	var EAbilityCostEditMode Mode;
 
-	// Base cost parameters
 	var bool SetFreeCost;
+	// Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.
 	var bool FreeCost;
 
-	// Optional child-class parameters
 	var bool SetNumPoints;
+	// Action points the ability consumes.
 	var int NumPoints;
 
 	var bool SetAddWeaponTypicalCost;
+	// Adds the weapon's own typical action cost on top of NumPoints.
 	var bool AddWeaponTypicalCost;
 
 	var bool SetConsumeAllPoints;
+	// Ends the turn by consuming every remaining action point, rather than just NumPoints.
 	var bool ConsumeAllPoints;
 
 	var bool SetMoveCost;
+	// Treats the cost as movement, so effects and abilities that key off moving apply.
 	var bool MoveCost;
 
+	// Action point types that may pay this cost. Restricting it stops the ability being
+	// paid for with, say, a Run-and-Gun point.
 	var array<name> AllowedTypes;
 	var ENameArrayEditMode AllowedTypesMode;
 
+	// If the user is under any of these effects, ConsumeAllPoints is ignored and the turn does not end.
 	var array<name> DoNotConsumeAllEffects;
 	var ENameArrayEditMode DoNotConsumeAllEffectsMode;
 
+	// If the user has any of these abilities, ConsumeAllPoints is ignored. This is how Blademaster lets Slash keep the turn going.
 	var array<name> DoNotConsumeAllSoldierAbilities;
 	var ENameArrayEditMode DoNotConsumeAllSoldierAbilitiesMode;
 
+	// Other abilities whose charges are spent alongside this one, as Skulljack and
+	// Skullmine share a pool. Applied when paying, never when checking affordability.
 	var array<name> SharedAbilityCharges;
 	var ENameArrayEditMode SharedAbilityChargesMode;
 
 	var bool SetFocusAmount;
+	// Templar focus consumed.
 	var int FocusAmount;
 
 	var bool SetConsumeAllFocus;
+	// Spends the user's entire focus pool rather than FocusAmount.
 	var bool ConsumeAllFocus;
 
 	var bool SetGhostOnlyCost;
+	// Only charges focus to a Ghost, leaving the original Templar's pool untouched.
 	var bool GhostOnlyCost;
 
 	var bool SetNumAmmo;
+	// Ammo consumed per use. With ConsumeAllAmmo set this becomes the minimum needed to
+	// fire, rather than the amount spent.
 	var int NumAmmo;
 
 	var bool SetUseLoadedAmmo;
+	// Draws from the loaded grenade rather than the weapon's ammo, for grenade-launcher abilities.
 	var bool UseLoadedAmmo;
 
 	var bool SetReturnChargesError;
+	// Reports a shortfall as "out of charges" instead of "out of ammo", for abilities
+	// presented to the player as charge-based.
 	var bool ReturnChargesError;
 
 	var bool SetConsumeAllAmmo;
+	// Spends the whole magazine. NumAmmo then only sets the minimum required to fire.
 	var bool ConsumeAllAmmo;
 
 	var bool SetNumCharges;
+	// Charges consumed per use.
 	var int NumCharges;
 
 	var bool SetOnlyOnHit;
+	// Only spends the charge when the ability hits, so a miss costs nothing.
 	var bool OnlyOnHit;
 
 	var bool SetAlsoExpendChargesOnSharedBondmateAbility;
+	// Also spends the bondmate's charges of the shared ability.
 	var bool AlsoExpendChargesOnSharedBondmateAbility;
 };
 
@@ -142,21 +164,27 @@ struct CooldownEdit
 	// Class name of the cooldown to instantiate
 	var string Class;
 
-	// Base cooldown parameters
 	var bool SetNumTurns;
+	// Turns the ability is unavailable after use.
 	var int NumTurns;
 
 	var bool SetIgnoreOnHit;
+	// Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.
 	var bool IgnoreOnHit;
 
 	var EAdditionalCooldownEditMode AdditionalCooldownMode;
+	// Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used
+	// where firing one thing should lock out another.
 	var array<AdditionalCooldownEdit> AdditionalCooldowns;
 
-	// Optional child-class parameters
 	var bool SetNumTurnsForAI;
+	// Cooldown used when the unit is AI-controlled, letting XCOM and the enemy run
+	// different timings. Only on X2AbilityCooldown_PerPlayerType.
 	var int NumTurnsForAI;
 
 	var bool SetNumGlobalTurns;
+	// Cooldown applied across every unit on the team, not just the one that used the
+	// ability. Only on the global cooldown classes.
 	var int NumGlobalTurns;
 };
 
@@ -165,17 +193,19 @@ struct ChargesEdit
 	// Class name of the charge to instantiate
 	var string Class;
 
-	// Base cooldown parameters
 	var bool SetInitialCharges;
+	// Charges the ability starts a mission with.
 	var int InitialCharges;
 
 	var EChargesBonusMode BonusChargesMode;
+	// Extra charges granted when the unit has another ability, keyed by AbilityName.
+	// This is how Restoration adds charges to the medikit heal.
 	var array<BonusChargeEdit> BonusCharges;
 
 	var bool RemoveCharges;
 
-	// Optional child-class parameters
 	var bool SetStabilize;
+	// Whether the charges behave as the stabilise-style pool, on the charge classes that support it.
 	var bool Stabilize;
 };
 
@@ -195,411 +225,539 @@ struct ConditionEdit
 
 	// X2Condition_AbilityProperty
 	var ENameArrayEditMode OwnerHasSoldierAbilitiesMode;
+	// Soldier abilities the unit owning the ability must have.
 	var array<name> OwnerHasSoldierAbilities;
 
 	var bool SetTargetMustBeInValidTiles;
+	// Reject targets standing outside the ability's valid tiles.
 	var bool TargetMustBeInValidTiles;
 
 	// X2Condition_AbilitySourceWeapon
 	var bool SetWantsReload;
+	// Fail with AA_AmmoAlreadyFull when the source weapon's clip is already full.
 	var bool WantsReload;
 
 	var bool SetCheckAmmo;
+	// Compare the source weapon's ammo against CheckAmmoData.
 	var bool CheckAmmo;
 
 	var bool SetCheckAmmoData;
+	// The ammo check used when CheckAmmo is true: Value, CheckType, and ValueMin/ValueMax for range checks.
 	var CheckConfig CheckAmmoData;
 
 	var bool SetNotLoadedAmmoInSecondaryWeapon;
+	// Fail when the source weapon is currently loaded as ammo in the secondary weapon.
 	var bool NotLoadedAmmoInSecondaryWeapon;
 
 	var bool SetMatchGrenadeType;
+	// Grenade template the source weapon, or its loaded ammo, must be.
 	var name MatchGrenadeType;
 
 	var bool SetCheckGrenadeFriendlyFire;
+	// Reject friendly targets unless the grenade template allows friendly fire.
 	var bool CheckGrenadeFriendlyFire;
 
 	var bool SetCheckAmmoTechLevel;
+	// Reject the source ammo when it is not valid for the unit's primary weapon.
 	var bool CheckAmmoTechLevel;
 
 	var bool SetMatchWeaponTemplate;
+	// Weapon template the source weapon must be, exact match on its DataName.
 	var name MatchWeaponTemplate;
 
 	// X2Condition_DarkEvent
 	var bool SetStilettoRounds;
+	// Pass only while the Stiletto Rounds dark event is active.
 	var bool StilettoRounds;
 
 	// X2Condition_GameplayTag
 	var bool SetRequiredGameplayTag;
+	// Tactical gameplay tag XCOM HQ must carry for the ability to be valid.
 	var name RequiredGameplayTag;
 
 	var bool SetDisallowGameplayTag;
+	// Tactical gameplay tag that makes the ability invalid while XCOM HQ carries it.
 	var name DisallowGameplayTag;
 
+	// X2Condition_GameTime
+	var ENameArrayEditMode HourChecksMode;
+	// Checks against the current hour of the day; the condition passes when any one of them does. Merge adds checks not already present.
+	var array<CheckConfig> HourChecks;
+
 	// X2Condition_PlayerTurns
 	var bool SetNumTurnsCheck;
+	// Check against the number of turns the target's controlling player has taken.
 	var CheckConfig NumTurnsCheck;
 
 	// X2Condition_UnitActionPoints (merged by ActionPointType)
 	var ENameArrayEditMode ActionPointChecksMode;
+	// Action point checks; passes when any one of them does. Each names an action point type, whether to count reserved points, and the value check.
 	var array<ActionPointCheck> ActionPointChecks;
 
 	// X2Condition_UnitAlertStatus
 	var bool SetRequiredAlertStatusMaximum;
+	// Highest alert level the unit may have. -1 ignores it; the condition fails when both limits are -1.
 	var int RequiredAlertStatusMaximum;
 
 	var bool SetRequiredAlertStatusMinimum;
+	// Lowest alert level the unit may have. -1 ignores it; the condition fails when both limits are -1.
 	var int RequiredAlertStatusMinimum;
 
 	// X2Condition_UnitEffects and its subclasses (merged by EffectName)
 	var ENameArrayEditMode ExcludeEffectsMode;
+	// Effects that reject the unit when present, each with the failure reason to return.
 	var array<EffectReason> ExcludeEffects;
 
 	var ENameArrayEditMode RequireEffectsMode;
+	// Effects that must all be present on the unit, each with the failure reason to return.
 	var array<EffectReason> RequireEffects;
 
 	// X2Condition_UnitImmunities
 	var ENameArrayEditMode ExcludeDamageTypesMode;
+	// Damage types; a unit immune to any of them is rejected.
 	var array<name> ExcludeDamageTypes;
 
 	var bool SetOnlyOnCharacterTemplate;
+	// Consider only the immunities of the unit's character template, not those granted by effects.
 	var bool OnlyOnCharacterTemplate;
 
-	// X2Condition_UnitInteractions
+	// X2Condition_UnitInteractions, X2Condition_Interactive
 	var bool SetInteractionType;
+	// Kind of interaction point the unit must be next to: eInteractionType_Normal or eInteractionType_Hack.
 	var UnitInterationType InteractionType;
 
 	// X2Condition_UnitInventory
 	var bool SetRelevantSlot;
+	// Inventory slot whose item is checked.
 	var EInventorySlot RelevantSlot;
 
 	var bool SetExcludeWeaponCategory;
+	// Weapon category that rejects the unit when the item in RelevantSlot has it.
 	var name ExcludeWeaponCategory;
 
 	var bool SetRequireWeaponCategory;
+	// Weapon category the item in RelevantSlot must have. Fails when the slot is empty.
 	var name RequireWeaponCategory;
 
 	// X2Condition_UnitProperty
 	var bool SetExcludeAlive;
+	// Reject living units.
 	var bool ExcludeAlive;
 
 	var bool SetExcludeDead;
+	// Reject dead units.
 	var bool ExcludeDead;
 
 	var bool SetExcludeRobotic;
+	// Reject robotic units.
 	var bool ExcludeRobotic;
 
 	var bool SetExcludeOrganic;
+	// Reject organic units.
 	var bool ExcludeOrganic;
 
 	var bool SetExcludeCivilian;
+	// Reject units whose character template is civilian, whatever their team.
 	var bool ExcludeCivilian;
 
 	var bool SetExcludeNonCivilian;
+	// Reject units whose character template is not civilian, whatever their team.
 	var bool ExcludeNonCivilian;
 
 	var bool SetExcludeCosmetic;
+	// Reject cosmetic units, such as Gremlins.
 	var bool ExcludeCosmetic;
 
 	var bool SetExcludeImpaired;
+	// Reject impaired units.
 	var bool ExcludeImpaired;
 
 	var bool SetExcludePanicked;
+	// Reject panicked units.
 	var bool ExcludePanicked;
 
 	var bool SetExcludeInStasis;
+	// Reject units in stasis.
 	var bool ExcludeInStasis;
 
 	var bool SetExcludeTurret;
+	// Reject turrets.
 	var bool ExcludeTurret;
 
 	var bool SetExcludePsionic;
+	// Reject psionic units.
 	var bool ExcludePsionic;
 
 	var bool SetExcludeNonPsionic;
+	// Reject non-psionic units.
 	var bool ExcludeNonPsionic;
 
 	var bool SetIsAdvent;
+	// Require an ADVENT unit.
 	var bool IsAdvent;
 
 	var bool SetExcludeAdvent;
+	// Reject ADVENT units.
 	var bool ExcludeAdvent;
 
 	var bool SetExcludeNoCover;
+	// Reject units that are not in cover.
 	var bool ExcludeNoCover;
 
 	var bool SetExcludeNoCoverToSource;
+	// Reject units with no cover between them and the source.
 	var bool ExcludeNoCoverToSource;
 
 	var bool SetExcludeFullHealth;
+	// Reject units at full HP, unless a persistent damage effect listed in MedikitHealEffectTypes is on them.
 	var bool ExcludeFullHealth;
 
 	var bool SetIsBleedingOut;
+	// Require a unit that is bleeding out.
 	var bool IsBleedingOut;
 
 	var bool SetIsUnspotted;
+	// Require a unit that has not been spotted.
 	var bool IsUnspotted;
 
 	var bool SetCanBeCarried;
+	// Require a unit that can be carried.
 	var bool CanBeCarried;
 
 	var bool SetIsOutdoors;
+	// Require a unit standing outdoors.
 	var bool IsOutdoors;
 
 	var bool SetIsConcealed;
+	// Require a concealed unit.
 	var bool IsConcealed;
 
 	var bool SetExcludeConcealed;
+	// Reject concealed units. Only applies to the check without a source; visibility rules normally cover this.
 	var bool ExcludeConcealed;
 
 	var bool SetIsSuperConcealed;
+	// Require a unit in super concealment.
 	var bool IsSuperConcealed;
 
 	var bool SetIsImpaired;
+	// Require an impaired unit.
 	var bool IsImpaired;
 
 	var bool SetHasClearanceToMaxZ;
+	// Require open space above the unit up to the map ceiling.
 	var bool HasClearanceToMaxZ;
 
 	var bool SetExcludeAlien;
+	// Reject alien units.
 	var bool ExcludeAlien;
 
 	var bool SetExcludeNonHumanoidAliens;
+	// Reject aliens that are not humanoid.
 	var bool ExcludeNonHumanoidAliens;
 
 	var bool SetExcludeStunned;
+	// Reject stunned units.
 	var bool ExcludeStunned;
 
 	var bool SetExcludeDazed;
+	// Reject dazed units.
 	var bool ExcludeDazed;
 
 	var bool SetExcludeUnableToAct;
+	// Reject units that are unable to act.
 	var bool ExcludeUnableToAct;
 
 	var bool SetIsPlayerControlled;
+	// Require a player-controlled unit.
 	var bool IsPlayerControlled;
 
 	var bool SetExcludeUnrevealedAI;
+	// Reject AI units that have not been revealed yet.
 	var bool ExcludeUnrevealedAI;
 
 	var bool SetIncludeWeakAgainstTechLikeRobot;
+	// Treat units flagged as weak against tech as robotic for the robotic checks.
 	var bool IncludeWeakAgainstTechLikeRobot;
 
 	var bool SetImpairedIgnoresStuns;
+	// Do not count stuns when deciding whether a unit is impaired.
 	var bool ImpairedIgnoresStuns;
 
 	var bool SetIsScampering;
+	// Require a unit that is currently scampering.
 	var bool IsScampering;
 
 	var bool SetExcludeDeadFromSpecialDeath;
+	// Reject units killed by a special death.
 	var bool ExcludeDeadFromSpecialDeath;
 
 	var bool SetExcludeLargeUnits;
+	// Reject units larger than one tile.
 	var bool ExcludeLargeUnits;
 
 	var bool SetImpairedIgnoresImpairingMomentarily;
+	// Do not count momentary impairment when deciding whether a unit is impaired.
 	var bool ImpairedIgnoresImpairingMomentarily;
 
 	var bool SetMinRank;
+	// Lowest soldier rank allowed.
 	var int MinRank;
 
 	var bool SetMaxRank;
+	// Highest soldier rank allowed.
 	var int MaxRank;
 
 	var ENameArrayEditMode ExcludeSoldierClassesMode;
+	// Soldier classes that reject the unit. Non-soldiers always pass.
 	var array<name> ExcludeSoldierClasses;
 
 	var ENameArrayEditMode RequireSoldierClassesMode;
+	// Soldier classes the unit must be one of, when non-empty. Non-soldiers always fail.
 	var array<name> RequireSoldierClasses;
 
 	var bool SetExcludeHostileToSource;
+	// Reject units hostile to the source.
 	var bool ExcludeHostileToSource;
 
 	var bool SetExcludeFriendlyToSource;
+	// Reject units friendly to the source.
 	var bool ExcludeFriendlyToSource;
 
 	var bool SetTreatMindControlledSquadmateAsHostile;
+	// Count a mind-controlled squadmate as hostile rather than friendly.
 	var bool TreatMindControlledSquadmateAsHostile;
 
 	var bool SetExcludeSquadmates;
+	// Reject units on the same team as the source.
 	var bool ExcludeSquadmates;
 
 	var bool SetRequireSquadmates;
+	// Require the unit to be on the same team as the source.
 	var bool RequireSquadmates;
 
 	var bool SetRequireWithinRange;
+	// Require the unit to be within WithinRange of the source.
 	var bool RequireWithinRange;
 
 	var bool SetWithinRange;
+	// Maximum distance between source and target, in Unreal units. A tile is 96.
 	var float WithinRange;
 
 	var bool SetRequireWithinMinRange;
+	// Require the unit to be within WithinMinRange of the source.
 	var bool RequireWithinMinRange;
 
 	var bool SetWithinMinRange;
+	// Distance for the minimum-range check, in Unreal units. A tile is 96.
 	var float WithinMinRange;
 
 	var bool SetBeingCarriedBySource;
+	// Require a unit currently carried by the source.
 	var bool BeingCarriedBySource;
 
 	var bool SetRequireUnitSelectedFromHQ;
+	// Require a unit that was selected from Headquarters for the mission. XCOM only.
 	var bool RequireUnitSelectedFromHQ;
 
 	var bool SetFailOnNonUnits;
+	// Fail with AA_NotAUnit on non-unit targets instead of passing them through.
 	var bool FailOnNonUnits;
 
 	// X2Condition_UnitStatCheck (merged by StatType)
 	var ENameArrayEditMode CheckStatsMode;
+	// Stat checks that must all pass: the stat, the value check, and whether to compare as a percentage of the stat's maximum.
 	var array<CheckStat> CheckStats;
 
 	// X2Condition_UnitType
 	var ENameArrayEditMode IncludeTypesMode;
+	// Character groups the unit must belong to, when non-empty. Takes precedence over ExcludeTypes.
 	var array<name> IncludeTypes;
 
 	var ENameArrayEditMode ExcludeTypesMode;
+	// Character groups that reject the unit. Ignored while IncludeTypes is non-empty.
 	var array<name> ExcludeTypes;
 
 	// X2Condition_UnitValue (merged by UnitValue)
 	var ENameArrayEditMode CheckValuesMode;
+	// Unit value checks that must all pass: the value name, the value check, and an optional failure code to return instead of the default.
 	var array<CheckValue> CheckValues;
 
 	// X2Condition_Visibility
 	var bool SetNoEnemyViewers;
+	// Fail when any enemy can see the target.
 	var bool NoEnemyViewers;
 
 	var bool SetRequireMatchCoverType;
+	// Require the target to be in the cover type given by TargetCover.
 	var bool RequireMatchCoverType;
 
 	var bool SetRequireNotMatchCoverType;
+	// Require the target not to be in the cover type given by TargetCover.
 	var bool RequireNotMatchCoverType;
 
 	var bool SetTargetCover;
+	// Cover type used by RequireMatchCoverType and RequireNotMatchCoverType.
 	var ECoverType TargetCover;
 
 	var bool SetCannotPeek;
+	// Require the shooter to see the target from its own tile, without peeking.
 	var bool CannotPeek;
 
 	var bool SetRequireLOS;
+	// Require line of sight.
 	var bool RequireLOS;
 
 	var bool SetRequireBasicVisibility;
+	// Require line of sight and range.
 	var bool RequireBasicVisibility;
 
 	var bool SetRequireGameplayVisible;
+	// Require line of sight, range and the situational gameplay-visibility rules.
 	var bool RequireGameplayVisible;
 
 	var bool SetAllowSquadsight;
+	// Accept any squadmate's view of the target if the unit has Squadsight. Overrides RequireGameplayVisible.
 	var bool AllowSquadsight;
 
 	var bool SetActAsSquadsight;
+	// Accept any squadmate's view of the target whether or not the unit has Squadsight. Overrides RequireGameplayVisible.
 	var bool ActAsSquadsight;
 
 	var bool SetVisibleToAnyAlly;
+	// Accept the target when any squadmate can see it, without line of sight from the unit itself. Overrides RequireGameplayVisible.
 	var bool VisibleToAnyAlly;
 
 	var bool SetDisablePeeksOnMovement;
+	// Forbid peeking once the target has moved.
 	var bool DisablePeeksOnMovement;
 
 	var bool SetExcludeGameplayVisible;
+	// Fail when the target has gameplay visibility of the source.
 	var bool ExcludeGameplayVisible;
 
 	var ENameArrayEditMode RequireGameplayVisibleTagsMode;
+	// Visibility tags that must be present on the visibility info, such as concealed or stealthed.
 	var array<name> RequireGameplayVisibleTags;
 
 	// X2Condition_BattleState
 	var bool SetMissionAborted;
+	// Require the mission to have been aborted.
 	var bool MissionAborted;
 
 	// X2Condition_BattleState
 	var bool SetMissionNotAborted;
+	// Require the mission not to have been aborted.
 	var bool MissionNotAborted;
 
 	// X2Condition_BattleState
 	var bool SetCiviliansTargetedByAliens;
+	// Require a mission where aliens target civilians.
 	var bool CiviliansTargetedByAliens;
 
 	// X2Condition_BattleState
 	var bool SetCiviliansNotTargetedByAliens;
+	// Require a mission where aliens do not target civilians.
 	var bool CiviliansNotTargetedByAliens;
 
 	// X2Condition_BattleState
 	var bool SetIncludeTheLostInEngagedCount;
+	// Count the Lost among the engaged enemies.
 	var bool IncludeTheLostInEngagedCount;
 
 	// X2Condition_BattleState
 	var bool SetMinEngagedEnemies;
+	// Fewest engaged enemies required. -1 ignores it.
 	var int MinEngagedEnemies;
 
 	// X2Condition_BattleState
 	var bool SetMaxEngagedEnemies;
+	// Most engaged enemies allowed. -1 ignores it.
 	var int MaxEngagedEnemies;
 
 	// X2Condition_BerserkerDevastatingPunch
 	var bool SetFailOnNonUnitTargets;
+	// Fail with AA_NotAUnit on non-unit targets instead of passing them through.
 	var bool FailOnNonUnitTargets;
 
 	// X2Condition_Bondmate
 	var bool SetMinBondLevel;
+	// Lowest bond level between the two units, inclusive.
 	var int MinBondLevel;
 
 	// X2Condition_Bondmate
 	var bool SetMaxBondLevel;
+	// Highest bond level between the two units, inclusive.
 	var int MaxBondLevel;
 
 	// X2Condition_Bondmate
 	var bool SetRequiresAdjacency;
+	// Whether the bondmates may, must not, or must be adjacent: EAR_AnyAdjacency, EAR_DisallowAdjacency or EAR_RequireAdjacency.
 	var AdjacencyRequirement RequiresAdjacency;
 
 	// X2Condition_Bondmate
 	var bool SetSkipCheckWithSource;
+	// Only check that the source has a bondmate on the mission, not that the target is that bondmate. For self-targeted bondmate abilities.
 	var bool SkipCheckWithSource;
 
 	// X2Condition_HackingTarget
 	var bool SetIntrusionProtocol;
+	// Hack objects at range: needs gameplay visibility of the object instead of an adjacent interaction point.
 	var bool IntrusionProtocol;
 
 	// X2Condition_HackingTarget
 	var bool SetHaywireProtocol;
+	// Target units instead of objects: living, unhacked, robotic enemies the unit sees or has squadsight on.
 	var bool HaywireProtocol;
 
 	// X2Condition_HackingTarget, X2Condition_Interactive
 	var bool SetRequiredAbilityName;
+	// Ability the interactive object must expose. For hacking, empty accepts any object; for a normal interaction it must match exactly.
 	var name RequiredAbilityName;
 
 	// X2Condition_HackingTarget
 	var bool SetMustBeDoor;
+	// Require the object to be a door.
 	var bool MustBeDoor;
 
 	// X2Condition_Lootable
 	var bool SetRestrictRange;
+	// Require the loot to be within LootableRange of the source.
 	var bool RestrictRange;
 
 	// X2Condition_Lootable
 	var bool SetLootableRange;
+	// Maximum distance to the loot, in Unreal units, when RestrictRange is set. A tile is 96.
 	var int LootableRange;
 
 	// X2Condition_OnGroundTile
 	var bool SetNotAFloorTileTag;
+	// Tag of tiles that must not count as ground.
 	var name NotAFloorTileTag;
 
 	// X2Condition_PanicOnPod
 	var bool SetMaxPanicUnitsPerPod;
+	// Most units of an AI pod that may be panicked at once. 0 removes the limit.
 	var int MaxPanicUnitsPerPod;
 
 	// X2Condition_StasisLanceTarget
 	var bool SetHackAbilityName;
+	// Hack ability whose rewards the target must offer, e.g. FinalizeSKULLJACK.
 	var Name HackAbilityName;
 
 	// X2Condition_Stealth
 	var bool SetCheckFlanking;
+	// Fail when any enemy flanks the unit.
 	var bool CheckFlanking;
 
 	// X2Condition_UnblockedNeighborTile
 	var bool SetRequireVisible;
+	// Require a free neighbouring tile the unit could be pulled to, rather than any free neighbouring tile.
 	var bool RequireVisible;
 
 	// X2Condition_MapProperty
 	var ENameArrayEditMode AllowedBiomesMode;
+	// Map biomes the mission must be in, when non-empty.
 	var array<string> AllowedBiomes;
 
 	var array<AECustomProperty> CustomProperties;
@@ -657,975 +815,1396 @@ struct EffectEdit
 	var EAbilityEffectSlot Slot;
 	var EArrayEditMode Mode;
 
-	// Base effect parameters
+	// Nested tick effects (X2Effect_Persistent.ApplyOnTick)
+	//
+	// A persistent effect is a state; the thing it actually does each turn lives in a
+	// child effect inside its ApplyOnTick array. Burning for example:
+	// X2Effect_Burning object only carries duration, while the damage sits in an
+	// X2Effect_ApplyWeaponDamage that SetBurnDamage() puts at ApplyOnTick[0].
+	//
+	// Setting ApplyOnTickClass redirects this whole entry at that child, so every field
+	// below applies to it instead of to the parent.
+	var string ApplyOnTickClass;
+	var int ApplyOnTickIndex;
+	var EArrayEditMode ApplyOnTickMode;
+
 	var bool SetApplyOnHit;
+	// Whether the effect is applied when the ability hits. Most effects want this true;
+	// setting it false is how an effect is made to trigger only on a miss.
 	var bool ApplyOnHit;
 
 	var bool SetApplyOnMiss;
+	// Whether the effect is applied even when the ability misses.
 	var bool ApplyOnMiss;
 
 	var bool SetApplyChance;
+	// Percentage chance the effect applies at all, rolled per target. 0 behaves as
+	// "always", since the roll is only made when a chance is set.
 	var int ApplyChance;
 
 	var bool SetApplyToWorldOnHit;
+	// Whether the effect is applied to the world (tiles, cover, environment) on a hit,
+	// rather than to a unit. Used by fire, smoke, acid and the other world effects.
 	var bool ApplyToWorldOnHit;
 
 	var bool SetApplyToWorldOnMiss;
+	// As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still
+	// affect the ground when they scatter.
 	var bool ApplyToWorldOnMiss;
 
 	var bool SetUseSourcePlayerState;
+	// Records the source player on the effect when it is applied, so later logic can tell
+	// whose effect it was. Needed by effects that behave differently for XCOM and the AI.
 	var bool UseSourcePlayerState;
 
 	var bool SetIsImpairing;
+	// Marks the effect as impairing the unit, which fires the impairment event and makes
+	// the unit report as impaired. This is what stuns, panic and disorientation use.
 	var bool IsImpairing;
 
 	var bool SetIsImpairingMomentarily;
+	// Fires the impairment event without leaving the unit flagged as impaired afterwards.
+	// For effects that interrupt an action but do not linger.
 	var bool IsImpairingMomentarily;
 
 	var bool SetBringRemoveVisualizationForward;
+	// Moves this effect's removal visualization earlier in the sequence, taking the whole
+	// context's visualization with it. Used when a removal must be seen before what follows.
 	var bool BringRemoveVisualizationForward;
 
 	var bool SetShowImmunity;
+	// Shows a flyover when the target is immune to this effect. Only when the application
+	// actually failed because of immunity.
 	var bool ShowImmunity;
 
 	var bool SetShowImmunityAnyFailure;
+	// Shows the immunity flyover whenever the effect fails to apply for any reason, not
+	// only immunity. Broader, and noisier, than ShowImmunity.
 	var bool ShowImmunityAnyFailure;
 
 	var bool SetAppliesDamage;
+	// Marks the effect as dealing damage, so it counts towards damage statistics and
+	// raises the generic ability-damage events. Set it on any custom source of damage.
 	var bool AppliesDamage;
 
 	var bool SetCanBeRedirected;
+	// Whether the effect is eligible to be redirected onto another target, by Untouchable,
+	// Bladestorm parries and similar. Leave false for effects that must hit their target.
 	var bool CanBeRedirected;
 
 	var bool SetHideDeathWorldMessage;
+	// Suppresses the usual death message when this effect is what kills the unit, for
+	// deaths that should read as something other than a normal kill.
 	var bool HideDeathWorldMessage;
 
 	var ENameArrayEditMode DamageTypesMode;
+	// Damage types this effect counts as. A unit immune to any type listed here resists the
+	// effect, and cleansing effects look at these types to decide what they can remove.
 	var array<name> DamageTypes;
 
 	// Conditions attached to the effect (X2Effect.TargetConditions)
 	var array<ConditionEdit> TargetConditions;
 
 	var bool SetMinStatContestResult;
+	// For effects resolved by a stat contest: the contest result must be at least this for
+	// the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.
 	var int MinStatContestResult;
 
 	var bool SetMaxStatContestResult;
+	// Upper bound of the same stat-contest band. Ignored when it is below
+	// MinStatContestResult.
 	var int MaxStatContestResult;
 
 	var bool SetDelayVisualizationSec;
+	// Seconds to delay this effect's visualization, for sequencing it against the rest of
+	// the ability rather than changing any game state.
 	var float DelayVisualizationSec;
 
 	var bool SetOverrideMissMessage;
+	// Replaces the usual "Miss" flyover with your own text, for abilities where a miss
+	// should read as something else.
 	var string OverrideMissMessage;
 
-	// Option child-class parameters
 	var bool SetNumTurns;
+	// How many turns the effect lasts. Ignored when InfiniteDuration is true.
 	var int NumTurns;
 
 	var bool SetInitialShedChance;
+	// Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.
 	var int InitialShedChance;
 
 	var bool SetPerTurnShedChance;
+	// Percentage chance per tick that the effect wears off early. 0 means it only ends
+	// when its turns run out.
 	var int PerTurnShedChance;
 
 	var bool SetEffectRank;
+	// Precedence among effects of the same kind, used by auras so a stronger source
+	// wins over a weaker one.
 	var int EffectRank;
 
 	var bool SetEffectHierarchyValue;
+	// Decides which effect controls the unit’s animation when several apply at once.
+	// The higher value wins.
 	var int EffectHierarchyValue;
 
 	var bool SetVisionArcDegreesOverride;
+	// Narrows the unit’s sight arc to this many degrees. When two effects both set it,
+	// the smaller arc applies.
 	var float VisionArcDegreesOverride;
 
 	var bool SetInfiniteDuration;
+	// The effect never expires on its own. It then only ends through one of the
+	// RemoveWhen... rules below, or by something cleansing it.
 	var bool InfiniteDuration;
 
 	var bool SetTickWhenApplied;
+	// Ticks once the moment it is applied, rather than waiting for the turn to come
+	// round. Damage-over-time effects use this to hurt immediately.
 	var bool TickWhenApplied;
 
 	var bool SetCanTickEveryAction;
+	// Ticks after every action the target takes rather than once a turn, where the
+	// character template supports it.
 	var bool CanTickEveryAction;
 
 	var bool SetConvertTurnsToActions;
+	// When ticking per action, multiplies NumTurns by the actions available per turn,
+	// so a "3 turn" effect still lasts roughly three turns.
 	var bool ConvertTurnsToActions;
 
 	var bool SetRemoveWhenSourceDies;
+	// Removes the effect when whoever applied it dies. Typical for effects sustained
+	// by their caster, such as mind control.
 	var bool RemoveWhenSourceDies;
 
 	var bool SetRemoveWhenTargetDies;
+	// Removes the effect when the affected unit dies, rather than leaving it on the body.
 	var bool RemoveWhenTargetDies;
 
 	var bool SetRemoveWhenSourceDamaged;
+	// Removes the effect as soon as the source takes damage, for concentration-style
+	// effects broken by being hit.
 	var bool RemoveWhenSourceDamaged;
 
 	var bool SetRemoveWhenTargetConcealmentBroken;
+	// Removes the effect when the target loses concealment. Used by effects that only
+	// make sense while hidden.
 	var bool RemoveWhenTargetConcealmentBroken;
 
 	var bool SetPersistThroughTacticalGameEnd;
+	// Keeps the effect on the unit after it leaves play, until the mission ends. Needed
+	// by effects that must still be read when the mission is scored.
 	var bool PersistThroughTacticalGameEnd;
 
 	var bool SetIgnorePlayerCheckOnTick;
+	// Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.
 	var bool IgnorePlayerCheckOnTick;
 
 	var bool SetUniqueTarget;
+	// Only one target may carry this effect from a given source at a time; applying it
+	// elsewhere removes the earlier one.
 	var bool UniqueTarget;
 
 	var bool SetStackOnRefresh;
+	// Re-applying the effect increments a stack counter instead of simply refreshing
+	// its duration, so effects that grow with repetition can read the count.
 	var bool StackOnRefresh;
 
 	var bool SetDupeForSameSourceOnly;
+	// When checking whether the target already has this effect, only consider copies
+	// from the same source. Lets several units apply their own instance.
 	var bool DupeForSameSourceOnly;
 
 	var bool SetEffectForcesBleedout;
+	// A unit reduced to zero health while under this effect bleeds out instead of dying outright.
 	var bool EffectForcesBleedout;
 
 	var bool SetDisplayInUI;
+	// Whether the effect appears in the unit’s status UI at all. An effect with no
+	// FriendlyName set will show as blank.
 	var bool DisplayInUI;
 
 	var bool SetDisplayInSpecialDamageMessageUI;
+	// Shows FriendlyName in the damage feedback as a distinct source, so its damage
+	// reads separately from the weapon’s.
 	var bool DisplayInSpecialDamageMessageUI;
 
 	var bool SetSourceDisplayInUI;
+	// As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.
 	var bool SourceDisplayInUI;
 
 	var bool SetCustomIdleOverrideAnim;
+	// Idle animation to play while the effect is active, taking over the unit’s normal idle.
 	var name CustomIdleOverrideAnim;
 
 	var bool SetEffectName;
+	// Identifier used when deciding how this effect stacks with others, and the name
+	// other effects use to find or remove it.
 	var name EffectName;
 
 	var bool SetAbilitySourceName;
+	// Which ability this is presented as coming from. Controls how a passive buff is
+	// coloured in the HUD.
 	var name AbilitySourceName;
 
 	var bool SetEffectAppliedEventName;
+	// Event fired when the effect is applied, for listeners and triggered abilities to react to.
 	var name EffectAppliedEventName;
 
 	var bool SetChanceEventTriggerName;
+	// Event fired when the per-turn shed-chance roll succeeds.
 	var name ChanceEventTriggerName;
 
 	var bool SetVFXSocket;
+	// Socket on the unit’s skeleton to attach the particle system to.
 	var name VFXSocket;
 
 	var bool SetVFXSocketsArrayName;
+	// Named array of sockets to attach the particle system to, for effects that appear
+	// in several places at once. Optional.
 	var name VFXSocketsArrayName;
 
 	var bool SetFriendlyName;
+	// Name shown in the unit’s status UI.
 	var string FriendlyName;
 
 	var bool SetFriendlyDescription;
+	// Description shown beneath FriendlyName in the status UI.
 	var string FriendlyDescription;
 
 	var bool SetIconImage;
+	// Path to the status icon shown in the UI.
 	var string IconImage;
 
 	var bool SetSourceFriendlyName;
+	// Name shown on the unit that applied the effect, as opposed to the one carrying it.
 	var string SourceFriendlyName;
 
 	var bool SetSourceFriendlyDescription;
+	// Description shown on the applying unit.
 	var string SourceFriendlyDescription;
 
 	var bool SetSourceIconLabel;
+	// Short label drawn on the applying unit’s icon.
 	var string SourceIconLabel;
 
 	var bool SetStatusIcon;
+	// Path to the small status icon used in condensed UI, alongside IconImage.
 	var string StatusIcon;
 
 	var bool SetVFXTemplateName;
+	// Particle system played on the unit for as long as the effect lasts.
 	var string VFXTemplateName;
 
 	var bool SetPersistentPerkName;
+	// Perk effect played on the unit while this effect is active.
 	var string PersistentPerkName;
 
 	// X2Effect_ApplyWeaponDamage
 	var bool SetExplosiveDamage;
+	// Counts the damage as explosive, so explosive-specific rules such as Blast Padding apply.
 	var bool ExplosiveDamage;
 
 	var bool SetIgnoreBaseDamage;
+	// Leave out the weapon's base damage; only the effect's own damage and tagged extra damage apply.
 	var bool IgnoreBaseDamage;
 
 	var bool SetDamageTag;
+	// Tag selecting one of the weapon's ExtraDamage entries and the upgrade bonus damage with the same tag.
 	var name DamageTag;
 
 	var bool SetAlwaysKillsCivilians;
+	// Civilian targets die outright regardless of the damage rolled.
 	var bool AlwaysKillsCivilians;
 
 	var bool SetApplyWorldEffectsForEachTargetLocation;
+	// Apply the ability's world effects at every target location instead of once.
 	var bool ApplyWorldEffectsForEachTargetLocation;
 
 	var bool SetAllowFreeKill;
+	// Let free-kill weapon upgrades, such as the Repeater, trigger on this damage.
 	var bool AllowFreeKill;
 
 	var bool SetAllowWeaponUpgrade;
+	// Let weapon upgrades add their bonus damage.
 	var bool AllowWeaponUpgrade;
 
 	var bool SetBypassShields;
+	// Damage ignores shield HP and goes straight to health.
 	var bool BypassShields;
 
 	var bool SetIgnoreArmor;
+	// Damage ignores armor.
 	var bool IgnoreArmor;
 
 	var bool SetBypassSustainEffects;
+	// Damage ignores sustain effects that would otherwise keep the unit alive.
 	var bool BypassSustainEffects;
 
 	var bool SetEnvironmentalDamageAmount;
+	// Environmental damage dealt to terrain and cover.
 	var int EnvironmentalDamageAmount;
 
+	// Damage the effect adds on its own, on top of the weapon: Damage, Spread, Crit, Pierce, Shred, Rupture, PlusOne, DamageType and Tag.
 	var WeaponDamageValueEdit WeaponDamageValue;
 
 	// X2Effect_PersistentStatChange
 	var EStatChangeMode StatChangeMode;
+	// Stat changes applied while the effect lasts, merged by StatType.
 	var array<StatChangeEdit> StatChange;
 
 	var bool SetCHLForceReapplyOnRefresh;
+	// Re-apply the stat changes when the effect is refreshed. Community Highlander field.
 	var bool CHLForceReapplyOnRefresh;
 
 	// X2AbilityEffectsEditor_DamageImmunity
 	// Maps to X2Effect_DamageImmunity.ImmueTypesAreInclusive (typo is Firaxis's)
 	var bool SetImmuneTypesAreInclusive;
+	// true: immune to the listed damage types only. false: immune to every damage type except the listed ones.
 	var bool ImmuneTypesAreInclusive;
 
 	var bool SetRemoveAfterAttackCount;
+	// Remove the effect after this many attacks against the unit. 0 keeps it.
 	var int RemoveAfterAttackCount;
 
 	var ENameArrayEditMode ImmuneTypesMode;
+	// Damage types the immunity covers, or excludes when ImmuneTypesAreInclusive is false.
 	var array<name> ImmuneTypes;
 
 	// X2Effect_GrantActionPoints
 	var bool SetNumActionPoints;
+	// Action points granted.
 	var int NumActionPoints;
 
 	var bool SetPointType;
+	// Type of action point granted, e.g. standard or move.
 	var name PointType;
 
 	var bool SetApplyOnlyWhenOut;
+	// Grant only when the unit has no standard action points left.
 	var bool ApplyOnlyWhenOut;
 
 	var bool SetSelectUnit;
+	// Select the unit in the tactical UI once the points are granted.
 	var bool SelectUnit;
 
 	var ENameArrayEditMode SkipWithEffectMode;
+	// Effects that, when present on the unit, skip the grant.
 	var array<name> SkipWithEffect;
 
+	// X2Effect_GrantActionPointsWithRecord (merged by UnitValueName)
+	var ENameArrayEditMode RecordUnitValueWithGrantMode;
+	// Unit values that accumulate the action points granted, each with its cleanup rule. Merge updates the entry with the same UnitValueName or adds it.
+	var array<RecordData> RecordUnitValueWithGrant;
+
 	// X2Effect_RemoveEffects
 	var ENameArrayEditMode EffectNamesToRemoveMode;
+	// Effect names removed from the target.
 	var array<name> EffectNamesToRemove;
 
 	var bool SetCleanse;
+	// Remove the effects as a cleanse, so whatever they do on wearing off does not trigger.
 	var bool Cleanse;
 
 	var bool SetCheckSource;
+	// Match effects whose source is this effect's target, instead of effects whose target it is.
 	var bool CheckSource;
 
 	var bool SetDoNotVisualize;
+	// Skip the removal visualization, for when another RemoveEffects on the ability already shows it.
 	var bool DoNotVisualize;
 
 	// X2Effect_SetUnitValue
 	var bool SetUnitName;
+	// Unit value written.
 	var name UnitName;
 
 	var bool SetNewValueToSet;
+	// Value written to the unit value.
 	var float NewValueToSet;
 
 	var bool SetCleanupType;
+	// When the unit value is cleared: eCleanup_BeginTurn, eCleanup_BeginTactical, eCleanup_Never or eCleanup_BeginTacticalChain.
 	var EUnitValueCleanup CleanupType;
 
 	// X2Effect_BonusArmor
 	var bool SetArmorMitigationAmount;
+	// Armor points granted while the effect lasts.
 	var int ArmorMitigationAmount;
 
 	// X2Effect_Stunned
 	var bool SetStunLevel;
+	// Action points the stun takes away.
 	var int StunLevel;
 
 	var bool SetSkipAnimation;
+	// Skip the stun animations.
 	var bool SkipAnimation;
 
 	var bool SetStunStartAnimName;
+	// Animation played when the stun starts, if the unit can play it.
 	var name StunStartAnimName;
 
 	var bool SetStunStopAnimName;
+	// Animation played when the stun ends.
 	var name StunStopAnimName;
 
 	var bool SetStunnedTriggerName;
+	// Event fired when the unit is stunned.
 	var name StunnedTriggerName;
 
 	// X2Effect_Sustained
 	var bool SetSustainedAbilityName;
+	// Ability on the source that is fired again once a full turn completes, to keep the effect going.
 	var name SustainedAbilityName;
 
 	var bool SetFragileAmount;
+	// Damage the source may take in a full turn before the effect breaks. 0 never breaks it.
 	var int FragileAmount;
 
 	var ENameArrayEditMode EffectsToRemoveFromSourceMode;
+	// Effects removed from the source when this effect ends.
 	var array<name> EffectsToRemoveFromSource;
 
 	var ENameArrayEditMode EffectsToRemoveFromTargetMode;
+	// Effects removed from the target when this effect ends.
 	var array<name> EffectsToRemoveFromTarget;
 
 	var ENameArrayEditMode RegisterAdditionalEventsLikeImpairMode;
+	// Extra events on the source that end the effect as if the source had become impaired.
 	var array<name> RegisterAdditionalEventsLikeImpair;
 
 	// X2Effect_Vanish
 	var bool SetReasonNotVisible;
+	// Visibility tag given as the reason the vanished unit cannot be seen.
 	var name ReasonNotVisible;
 
 	var bool SetVanishRevealAdditiveAnimName;
+	// Additive animation played on reveal when VanishRevealAnimName is empty.
 	var name VanishRevealAdditiveAnimName;
 
 	var bool SetVanishRevealAnimName;
+	// Animation played when the unit is revealed.
 	var name VanishRevealAnimName;
 
 	var bool SetVanishSyncAnimName;
+	// Additive animation played when the vanished state is visualized from a save.
 	var name VanishSyncAnimName;
 
 	// X2Effect_ReserveActionPoints
 	var bool SetReserveType;
+	// Type of action point reserved.
 	var name ReserveType;
 
 	var bool SetNumPoints;
+	// Number of action points reserved.
 	var int NumPoints;
 
 	// X2Effect_CoveringFire
 	var bool SetAbilityToActivate;
+	// Ability fired when the covering fire check matches.
 	var name AbilityToActivate;
 
 	var bool SetGrantActionPoint;
+	// Reserve action point given to the covering unit when the check matches.
 	var name GrantActionPoint;
 
 	var bool SetMaxPointsPerTurn;
+	// Most times per turn the action point can be granted. 0 or less removes the limit.
 	var int MaxPointsPerTurn;
 
 	var bool SetDirectAttackOnly;
+	// Only match when the unit carrying the effect is attacked directly.
 	var bool DirectAttackOnly;
 
 	var bool SetPreEmptiveFire;
+	// Fire before the attacker's shot resolves instead of after it.
 	var bool PreEmptiveFire;
 
 	var bool SetOnlyDuringEnemyTurn;
+	// Only fire during the enemy turn.
 	var bool OnlyDuringEnemyTurn;
 
 	var bool SetUseMultiTargets;
+	// Fire the ability at the covering unit itself and hit its multi-targets, instead of retaliating at the attacker.
 	var bool UseMultiTargets;
 
 	var bool SetOnlyWhenAttackMisses;
+	// Only fire when the attack missed.
 	var bool OnlyWhenAttackMisses;
 
 	var bool SetSelfTargeting;
+	// The fired ability targets the covering unit itself.
 	var bool SelfTargeting;
 
 	var bool SetActivationPercentChance;
+	// Percent chance the ability fires when the check matches. 0 always fires.
 	var int ActivationPercentChance;
 
 	// X2Effect_PersistentTraversalChange (merged by Traversal)
 	var ENameArrayEditMode TraversalChangesMode;
+	// Traversal types switched on or off while the effect lasts, merged by Traversal.
 	var array<TraversalChange> TraversalChanges;
 
 	// X2Effect_Achilles
 	var bool SetToHitMin;
+	// Lowest hit chance at which the damage multiplier applies.
 	var int ToHitMin;
 
 	// X2Effect_Achilles, X2Effect_AdverseSoldierClasses, X2Effect_Bewildered, X2Effect_Impatient, X2Effect_Nearsighted, X2Effect_Oblivious
 	var bool SetDmgMod;
+	// Multiplier applied to the damage when the effect's condition is met.
 	var float DmgMod;
 
 	// X2Effect_AdverseSoldierClasses
 	var ENameArrayEditMode AdverseClassesMode;
+	// Soldier classes whose attacks trigger the damage multiplier.
 	var array<name> AdverseClasses;
 
+	// X2Effect_AlertTheLost
+	var bool SetAlertRangeMeters;
+	// Radius in meters within which Lost are alerted.
+	var int AlertRangeMeters;
+
 	// X2Effect_Amplify
 	var bool SetBonusDamageMult;
+	// Fraction of the damage added as bonus.
 	var float BonusDamageMult;
 
 	// X2Effect_Amplify
 	var bool SetMinBonusDamage;
+	// Smallest bonus damage applied, when the fraction comes out lower.
 	var int MinBonusDamage;
 
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem1Tile;
+	// Particle system path for an acid pool covering a single tile.
+	var string AcidParticleSystem1Tile;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem2Tiles;
+	// Particle system path for an acid pool covering two tiles.
+	var string AcidParticleSystem2Tiles;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem3TilesLine;
+	// Particle system path for an acid pool covering three tiles in a line.
+	var string AcidParticleSystem3TilesLine;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem3TilesCorner;
+	// Particle system path for an acid pool covering three tiles in a corner.
+	var string AcidParticleSystem3TilesCorner;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesLine;
+	// Particle system path for an acid pool covering four tiles in a line.
+	var string AcidParticleSystem4TilesLine;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesSquare;
+	// Particle system path for an acid pool covering a 2x2 square.
+	var string AcidParticleSystem4TilesSquare;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesL;
+	// Particle system path for an acid pool covering four tiles in an L shape.
+	var string AcidParticleSystem4TilesL;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesReverseL;
+	// Particle system path for an acid pool covering four tiles in a mirrored L shape.
+	var string AcidParticleSystem4TilesReverseL;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesT;
+	// Particle system path for an acid pool covering four tiles in a T shape (the game's 4pc_Middle).
+	var string AcidParticleSystem4TilesT;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesS;
+	// Particle system path for an acid pool covering four tiles in an S shape.
+	var string AcidParticleSystem4TilesS;
+
+	// X2Effect_ApplyAcidToWorld
+	var bool SetAcidParticleSystem4TilesReverseS;
+	// Particle system path for an acid pool covering four tiles in a mirrored S shape.
+	var string AcidParticleSystem4TilesReverseS;
+
 	// X2Effect_ApplyBlazingPinionsTargetToWorld
-	var bool SetOverrideParticleSystemFill_Name;
-	var string OverrideParticleSystemFill_Name;
+	var bool SetOverrideParticleSystem;
+	// Particle system path played on the target instead of the default one. Empty keeps the default.
+	var string OverrideParticleSystem;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetDamageTypeTemplateName;
+	// Damage type of the environmental damage.
 	var name DamageTypeTemplateName;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetPlusNumZTiles;
+	// Extra tiles of height hit above the affected tile.
 	var int PlusNumZTiles;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetUseWeaponEnvironmentalDamage;
+	// Use the source weapon's environmental damage instead of EnvironmentalDamageAmount.
 	var bool UseWeaponEnvironmentalDamage;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetUseWeaponDamageType;
+	// Use the source weapon's damage type instead of DamageTypeTemplateName.
 	var bool UseWeaponDamageType;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetHitSourceTile;
+	// Apply the damage at the source's tile.
 	var bool HitSourceTile;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetHitTargetTile;
+	// Apply the damage at the target's tile.
 	var bool HitTargetTile;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetHitAdjacentDestructibles;
+	// Also damage destructibles adjacent to the hit tile along the damage direction.
 	var bool HitAdjacentDestructibles;
 
 	// X2Effect_ApplyDirectionalWorldDamage
 	var bool SetAllowDestructionOfDamageCauseCover;
+	// When a unit caused the damage, allow it to destroy that unit's own cover, which is normally protected.
 	var bool AllowDestructionOfDamageCauseCover;
 
 	// X2Effect_ApplyFireToWorld
 	var bool SetFireChance_Level1;
+	// Weight of a level 1 fire when rolling the intensity of new fires; relative to the other two levels.
 	var float FireChance_Level1;
 
 	// X2Effect_ApplyFireToWorld
 	var bool SetFireChance_Level2;
+	// Weight of a level 2 fire when rolling the intensity of new fires; relative to the other two levels.
 	var float FireChance_Level2;
 
 	// X2Effect_ApplyFireToWorld
 	var bool SetFireChance_Level3;
+	// Weight of a level 3 fire when rolling the intensity of new fires; relative to the other two levels.
 	var float FireChance_Level3;
 
 	// X2Effect_ApplyFireToWorld
 	var bool SetUseFireChanceLevel;
+	// Roll the fire intensity from the three FireChance weights instead of using the default.
 	var bool UseFireChanceLevel;
 
 	// X2Effect_ApplyFireToWorld
 	var bool SetDamageFragileOnly;
+	// Only damage fragile objects.
 	var bool DamageFragileOnly;
 
 	// X2Effect_ApplyFireToWorld
 	var bool SetCheckForLOSFromTargetLocation;
+	// Only set tiles on fire that are visible from the target location.
 	var bool CheckForLOSFromTargetLocation;
 
 	// X2Effect_ApplyMedikitHeal
 	var bool SetPerUseHP;
+	// HP healed per application.
 	var int PerUseHP;
 
 	// X2Effect_ApplyMedikitHeal
 	var bool SetIncreasedHealProject;
+	// Research that, once completed, switches the heal to IncreasedPerUseHP.
 	var name IncreasedHealProject;
 
 	// X2Effect_ApplyMedikitHeal
 	var bool SetIncreasedPerUseHP;
+	// HP healed per application once IncreasedHealProject is researched.
 	var int IncreasedPerUseHP;
 
+	// X2Effect_ApplyPoisonToWorld
+	var bool SetPoisonParticleSystem;
+	// Particle system path for a poison cloud tile.
+	var string PoisonParticleSystem;
+
+	// X2Effect_ApplySmokeToWorld, X2Effect_ApplySmokeGrenadeToWorld
+	var bool SetSmokeParticleSystem;
+	// Particle system path for a smoke tile.
+	var string SmokeParticleSystem;
+
 	// X2Effect_APRounds
 	var bool SetPierce;
+	// Armor pierced.
 	var int Pierce;
 
 	// X2Effect_APRounds, X2Effect_TalonRounds
 	var bool SetCritChance;
+	// Crit chance added.
 	var int CritChance;
 
 	// X2Effect_APRounds, X2Effect_TalonRounds
 	var bool SetCritDamage;
+	// Crit damage added.
 	var int CritDamage;
 
 	// X2Effect_Aura
 	var ENameArrayEditMode EventsToUpdateMode;
+	// Events that make the aura re-evaluate which units it covers.
 	var array<name> EventsToUpdate;
 
 	// X2Effect_Bewildered
 	var bool SetNumHitsForMod;
+	// Hits taken in the turn before the damage multiplier applies.
 	var int NumHitsForMod;
 
 	// X2Effect_BlastPadding
 	var bool SetExplosiveDamageReduction;
+	// Fraction of explosive damage removed.
 	var float ExplosiveDamageReduction;
 
 	// X2Effect_BloodTrail, X2Effect_HuntersInstinctDamage, X2Effect_VolatileMix
 	var bool SetBonusDamage;
+	// Bonus damage added when the effect's condition is met.
 	var int BonusDamage;
 
+	// X2Effect_BondmateAimAdjust
+	var bool SetThreatenedBondmateAimBonus;
+	// Aim bonus, from bond level 2, against a target that threatens the bondmate.
+	var int ThreatenedBondmateAimBonus;
+
+	// X2Effect_BondmateAimAdjust
+	var bool SetBondmateTargetAimBonus;
+	// Aim bonus, from bond level 3, against a target the bondmate attacked since last turn.
+	var int BondmateTargetAimBonus;
+
+	// X2Effect_BondmateAimAdjust
+	var bool SetBondmateTargetCritBonus;
+	// Crit bonus, from bond level 3, against a target the bondmate attacked since last turn.
+	var int BondmateTargetCritBonus;
+
+	// X2Effect_BondmateBleedout
+	var bool SetBleedoutDurationAdjustment;
+	// Turns added to the bleedout duration.
+	var int BleedoutDurationAdjustment;
+
 	// X2Effect_BonusWeaponDamage
 	var bool SetBonusDmg;
+	// Bonus damage added to the weapon's damage.
 	var int BonusDmg;
 
 	// X2Effect_Brutal
 	var bool SetWillMod;
+	// Change applied to the target's current Will; negative lowers it.
 	var int WillMod;
 
+	// X2Effect_CombatStims, X2Effect_Solace
+	var ENameArrayEditMode DamageTypeImmunitiesMode;
+	// Damage types the affected unit is immune to while the effect lasts.
+	var array<name> DamageTypeImmunities;
+
 	// X2Effect_ConditionalDamageModifier
 	var bool SetModifyOutgoingDamage;
+	// Apply to damage the unit deals.
 	var bool ModifyOutgoingDamage;
 
 	// X2Effect_ConditionalDamageModifier
 	var bool SetModifyIncomingDamage;
+	// Apply to damage the unit takes.
 	var bool ModifyIncomingDamage;
 
 	// X2Effect_ConditionalDamageModifier
 	var bool SetDamageModifier;
+	// Damage multiplier; 1.0 leaves the damage unchanged.
 	var float DamageModifier;
 
 	// X2Effect_ConditionalDamageModifier
 	var bool SetDamageBonus;
+	// Flat damage added after the multiplier.
 	var int DamageBonus;
 
+	// X2Effect_DeadeyeDamage
+	var bool SetDamageMultiplier;
+	// Extra damage as a fraction of the damage being dealt.
+	var float DamageMultiplier;
+
 	// X2Effect_DelayedAbilityActivation, X2Effect_FaceMultiRoundTarget, X2Effect_TriggerEvent
 	var bool SetTriggerEventName;
+	// Event the effect fires.
 	var name TriggerEventName;
 
 	// X2Effect_EnableGlobalAbility
 	var bool SetGlobalAbility;
+	// Global ability switched on for the rest of the battle.
 	var name GlobalAbility;
 
+	// X2Effect_Fortress
+	var ENameArrayEditMode DamageImmunitiesMode;
+	// Damage types the unit is immune to. The game assumes Fire, Acid and Poison are among them.
+	var array<name> DamageImmunities;
+
 	// X2Effect_GenerateCover
 	var bool SetCoverType;
+	// Cover the unit provides to others: none, low or high (ECoverForceFlag).
 	var ECoverForceFlag CoverType;
 
 	// X2Effect_GenerateCover
 	var bool SetRemoveWhenMoved;
+	// Remove the effect when the unit moves.
 	var bool RemoveWhenMoved;
 
 	// X2Effect_GenerateCover
 	var bool SetRemoveOnOtherActivation;
+	// Remove the effect when the unit activates another ability.
 	var bool RemoveOnOtherActivation;
 
 	// X2Effect_GetOverHere
 	var bool SetOverrideStartAnimName;
+	// Animation played on the pulled unit at the start, when set.
 	var Name OverrideStartAnimName;
 
 	// X2Effect_GetOverHere
 	var bool SetOverrideStopAnimName;
+	// Animation played on the pulled unit at the end, when set.
 	var Name OverrideStopAnimName;
 
 	// X2Effect_GetOverHere
 	var bool SetRequireVisibleTile;
+	// Only pull to a neighbouring tile the target can be bound to; otherwise any free neighbouring tile will do.
 	var bool RequireVisibleTile;
 
 	// X2Effect_Groundling
 	var bool SetHeightBonus;
+	// Extra aim an attacker gets when it has height advantage over the affected unit.
 	var int HeightBonus;
 
 	// X2Effect_Guardian
 	var ENameArrayEditMode AllowedAbilitiesMode;
+	// Abilities that can trigger the extra reaction shot.
 	var array<name> AllowedAbilities;
 
 	// X2Effect_Guardian
 	var bool SetProcChance;
+	// Percent chance of the extra reaction shot.
 	var int ProcChance;
 
 	// X2Effect_HoloTarget, X2Effect_SmokeGrenade
 	var bool SetHitMod;
+	// Hit chance modifier applied.
 	var int HitMod;
 
 	// X2Effect_HolyWarriorDeath
 	var bool SetDelayTimeS;
+	// Seconds before the death is visualized.
 	var float DelayTimeS;
 
 	// X2Effect_HomingMine
 	var bool SetAbilityToTrigger;
+	// Ability fired when the mine goes off.
 	var name AbilityToTrigger;
 
 	// X2Effect_HuntersInstinctDamage
 	var bool SetBonusCritChance;
+	// Crit chance added when the effect's condition is met.
 	var int BonusCritChance;
 
 	// X2Effect_ImmediateAbilityActivation
 	var bool SetAbilityName;
+	// Ability fired by the effect.
 	var name AbilityName;
 
 	// X2Effect_ImmediateAbilityActivation
 	var bool SetActivateAbilityOnTarget;
+	// Find and fire the ability on the target instead of the source.
 	var bool ActivateAbilityOnTarget;
 
 	// X2Effect_ImmediateAbilityActivation
 	var bool SetEffectTargetOnly;
+	// Fire only against the effect's target; false fires against every available target.
 	var bool EffectTargetOnly;
 
 	// X2Effect_Implacable
 	var bool SetImplacableThisTurnValue;
+	// Unit value that records Implacable already triggered this turn.
 	var name ImplacableThisTurnValue;
 
 	// X2Effect_IncreaseBondmateCohesion
 	var bool SetCohesionAmount;
+	// Cohesion added between the unit and its bondmate.
 	var int CohesionAmount;
 
 	// X2Effect_KineticPlating
 	var bool SetShieldPerMiss;
+	// Shield HP gained each time an attack misses the unit.
 	var int ShieldPerMiss;
 
 	// X2Effect_Knockback
 	var bool SetKnockbackDistance;
+	// Distance the unit is knocked back, in meters.
 	var int KnockbackDistance;
 
 	// X2Effect_Knockback
 	var bool SetKnockbackDestroysNonFragile;
+	// Let the knocked-back unit destroy non-fragile objects it hits.
 	var bool KnockbackDestroysNonFragile;
 
 	// X2Effect_Knockback
 	var bool SetOverrideRagdollFinishTimerSec;
+	// Seconds before the ragdoll settles. Negative keeps the default.
 	var float OverrideRagdollFinishTimerSec;
 
 	// X2Effect_Knockback
 	var bool SetOnlyOnDeath;
+	// Only knock back units the attack kills.
 	var bool OnlyOnDeath;
 
 	// X2Effect_LaserSight
 	var bool SetBenefitFromEmpoweredUpgrades;
+	// Increase the crit bonus when XCOM has empowered weapon upgrades. Community Highlander field.
 	var bool BenefitFromEmpoweredUpgrades;
 
 	// X2Effect_LaserSight
 	var bool SetCritBonus;
+	// Crit chance added on top of the distance-based bonus.
 	var int CritBonus;
 
 	// X2Effect_LifeSteal
 	var bool SetLifeAmountMultiplier;
+	// Multiplier on the health stolen. 0 leaves the amount unchanged.
 	var float LifeAmountMultiplier;
 
 	// X2Effect_MarkValidActivationTiles
 	var bool SetAbilityToMark;
+	// Ability whose valid activation tiles are marked.
 	var name AbilityToMark;
 
 	// X2Effect_MarkValidActivationTiles
 	var bool SetOnlyUseTargetLocation;
+	// Mark only the target location, ignoring the ability's multi-target area.
 	var bool OnlyUseTargetLocation;
 
 	// X2Effect_MarkValidActivationTiles
 	var bool SetVisualizeFlagsOnCursor;
+	// Show the marked tiles on the targeting cursor.
 	var bool VisualizeFlagsOnCursor;
 
 	// X2Effect_MeleeDamageAdjust
 	var bool SetDamageMod;
+	// Damage added to attacks of the melee damage type.
 	var int DamageMod;
 
 	// X2Effect_MeleeDamageAdjust
 	var bool SetMeleeDamageTypeName;
+	// Damage type that counts as melee for the adjustment.
 	var name MeleeDamageTypeName;
 
+	// X2Effect_MimicBeacon
+	var ENameArrayEditMode AbilitiesAllowedToHitMode;
+	// Abilities that may still target the mimic beacon.
+	var array<name> AbilitiesAllowedToHit;
+
 	// X2Effect_MindControl
 	var bool SetNumTurnsForAI;
+	// Turns the control lasts when an AI player is the controller. 0 uses the effect's normal duration.
 	var int NumTurnsForAI;
 
 	// X2Effect_ModifyInitiativeOrder
 	var bool SetRemoveGroupFromInitiativeOrder;
+	// Remove the unit's group from the initiative order.
 	var bool RemoveGroupFromInitiativeOrder;
 
 	// X2Effect_ModifyInitiativeOrder
 	var bool SetAddGroupToInitiativeOrder;
+	// Add the unit's group to the initiative order.
 	var bool AddGroupToInitiativeOrder;
 
 	// X2Effect_ModifyReactionFire
 	var bool SetAllowCrit;
+	// Allow reaction fire to crit.
 	var bool AllowCrit;
 
 	// X2Effect_ModifyReactionFire
 	var bool SetReactionModifier;
+	// Aim modifier applied to reaction fire.
 	var int ReactionModifier;
 
+	// X2Effect_ModifyStatCheckSuccesses (merged by AbilityName)
+	var ENameArrayEditMode AdditionalSuccessModifiersMode;
+	// Bonus successes added to a stat check made by the named ability, when the checked unit is the ability's source. Merge updates the entry with the same AbilityName or adds it.
+	var array<AdditionalSuccessModifier> AdditionalSuccessModifiers;
+
 	// X2Effect_ModifyTemplarFocus
 	var bool SetModifyFocus;
+	// Focus points added; negative removes them.
 	var int ModifyFocus;
 
 	// X2Effect_Needle
 	var bool SetArmorPierce;
+	// Armor pierced.
 	var int ArmorPierce;
 
 	// X2Effect_Obsessed
 	var bool SetObsessedTargetValueName;
+	// Unit value holding the object ID of the obsessed-over target.
 	var Name ObsessedTargetValueName;
 
+	// X2Effect_OverrideDeathAction
+	var bool SetDeathActionClass;
+	// Qualified class path of the X2Action that replaces the normal death visualization, e.g. XComGame.X2Action_ExplodingUnitDeathAction. Empty removes the override.
+	var string DeathActionClass;
+
 	// X2Effect_OverrideDeathAnimOnLoad
 	var bool SetOverrideAnimNameOnLoad;
+	// Death animation shown for the unit when a save is loaded.
 	var name OverrideAnimNameOnLoad;
 
 	// X2Effect_PaleHorse
 	var bool SetCritBoostPerKill;
+	// Crit chance gained per kill.
 	var int CritBoostPerKill;
 
 	// X2Effect_PaleHorse
 	var bool SetMaxCritBoost;
+	// Cap on the accumulated crit chance.
 	var int MaxCritBoost;
 
-	// X2Effect_ParthenogenicPoison
-	var bool SetParthenogenicPoisonType;
-	var name ParthenogenicPoisonType;
-
-	// X2Effect_ParthenogenicPoison
-	var bool SetParthenogenicPoisonCocoonSpawnedName;
-	var name ParthenogenicPoisonCocoonSpawnedName;
-
 	// X2Effect_ParthenogenicPoison, X2Effect_SpawnPsiZombie
 	var bool SetAltUnitToSpawnName;
+	// Character template spawned instead of the usual one, when set.
 	var name AltUnitToSpawnName;
 
 	// X2Effect_PersistentSquadViewer
 	var bool SetUseWeaponRadius;
+	// Use the source weapon's radius as the sight radius. Requires a source weapon.
 	var bool UseWeaponRadius;
 
 	// X2Effect_PersistentSquadViewer
 	var bool SetViewRadius;
+	// Sight radius of the viewer.
 	var float ViewRadius;
 
 	// X2Effect_PersistentSquadViewer
 	var bool SetUseSourceLocation;
+	// Place the viewer at the source's location rather than the target's.
 	var bool UseSourceLocation;
 
 	// X2Effect_PersistentVoidConduit
 	var bool SetInitialDamage;
+	// Damage dealt when the effect is applied.
 	var int InitialDamage;
 
 	// X2Effect_Possessed
 	var bool SetWeaponTemplateName;
+	// Item template equipped on the possessed unit.
 	var name WeaponTemplateName;
 
-	// X2Effect_Reaper
-	var bool SetReaperActivatedName;
-	var name ReaperActivatedName;
-
-	// X2Effect_Reaper
-	var bool SetReaperKillName;
-	var name ReaperKillName;
-
 	// X2Effect_ReduceCooldowns
 	var bool SetAmount;
+	// Turns taken off each cooldown.
 	var int Amount;
 
 	// X2Effect_ReduceCooldowns
 	var bool SetReduceAll;
+	// Clear the cooldowns entirely instead of reducing them by Amount.
 	var bool ReduceAll;
 
 	// X2Effect_ReduceCooldowns
 	var ENameArrayEditMode AbilitiesToTickMode;
+	// Abilities whose cooldowns are reduced. Empty means every ability.
 	var array<name> AbilitiesToTick;
 
 	// X2Effect_Regeneration
 	var bool SetHealAmount;
+	// HP healed per tick.
 	var int HealAmount;
 
 	// X2Effect_Regeneration
 	var bool SetMaxHealAmount;
+	// Total HP the effect may heal, tracked in HealthRegeneratedName. 0 removes the cap.
 	var int MaxHealAmount;
 
 	// X2Effect_Regeneration
 	var bool SetHealthRegeneratedName;
+	// Unit value that accumulates the HP healed so far, for the MaxHealAmount cap.
 	var name HealthRegeneratedName;
 
 	// X2Effect_Regeneration
 	var bool SetEventToTriggerOnHeal;
+	// Event fired after each heal.
 	var name EventToTriggerOnHeal;
 
 	// X2Effect_RemoteStart
 	var bool SetUnitDamageMultiplier;
+	// Multiplier on the damage the detonated object deals to units.
 	var float UnitDamageMultiplier;
 
 	// X2Effect_RemoteStart
 	var bool SetDamageRadiusMultiplier;
+	// Multiplier on the detonation's damage radius.
 	var float DamageRadiusMultiplier;
 
 	// X2Effect_RemoveEffectsByDamageType
 	var ENameArrayEditMode DamageTypesToRemoveMode;
+	// Effects carrying any of these damage types are removed.
 	var array<name> DamageTypesToRemove;
 
 	// X2Effect_ReserveOverwatchPoints
 	var ENameArrayEditMode UseAllPointsWithAbilitiesMode;
+	// Abilities that, when the unit has any of them, reserve as many points as were spent instead of NumPoints.
 	var array<name> UseAllPointsWithAbilities;
 
-	// X2Effect_RunBehaviorTree
+	// X2Effect_RunBehaviorTree, X2Effect_ChryssalidBurrowedAttack
 	var bool SetNumActions;
+	// Number of behavior tree actions the unit runs.
 	var int NumActions;
 
 	// X2Effect_RunBehaviorTree
 	var bool SetBehaviorTreeName;
+	// Behavior tree run on the unit.
 	var name BehaviorTreeName;
 
 	// X2Effect_RunBehaviorTree
 	var bool SetInitFromPlayer;
+	// Reset the behavior tree variables on each run as if the player turn were starting.
 	var bool InitFromPlayer;
 
 	// X2Effect_RunBehaviorTree
 	var bool SetSetActionPointCount;
+	// Standard action points given to the unit before the tree runs.
 	var int SetActionPointCount;
 
-	// X2Effect_ScanningProtocol
-	var bool SetLookAtDuration;
-	var float LookAtDuration;
-
 	// X2Effect_Shattered
 	var bool SetShatteredTargetValueName;
+	// Unit value holding the object ID of the unit that shattered the target.
 	var Name ShatteredTargetValueName;
 
 	// X2Effect_SoulSteal
 	var bool SetUnitValueToRead;
+	// Unit value read to find how much health to steal.
 	var name UnitValueToRead;
 
 	// X2Effect_SpawnDestructible
 	var bool SetDestructibleArchetype;
+	// Archetype path of the destructible actor spawned.
 	var string DestructibleArchetype;
 
 	// X2Effect_SpawnDestructible
 	var bool SetDestroyOnRemoval;
+	// Destroy the spawned actor when the effect is removed.
 	var bool DestroyOnRemoval;
 
 	// X2Effect_SpawnDestructible
 	var bool SetTargetableBySpawnedTeamOnly;
+	// Only the team that spawned the actor can target it.
 	var bool TargetableBySpawnedTeamOnly;
 
 	// X2Effect_SpawnPsiZombie
 	var bool SetAnimationName;
+	// Reanimation animation played on the corpse.
 	var name AnimationName;
 
 	// X2Effect_SpawnPsiZombie
 	var bool SetStartAnimationMinDelaySec;
+	// Shortest delay, in seconds, before the reanimation animation starts.
 	var float StartAnimationMinDelaySec;
 
 	// X2Effect_SpawnPsiZombie
 	var bool SetStartAnimationMaxDelaySec;
+	// Longest delay, in seconds, before the reanimation animation starts.
 	var float StartAnimationMaxDelaySec;
 
 	// X2Effect_SpawnShadowbindUnit
 	var bool SetShadowbindUnconciousCheckName;
+	// Unit value checked to tell whether the shadowbound unit was unconscious.
 	var name ShadowbindUnconciousCheckName;
 
 	// X2Effect_SpawnUnit
 	var bool SetUnitToSpawnName;
+	// Character template of the unit spawned.
 	var name UnitToSpawnName;
 
 	// X2Effect_SpawnUnit
 	var bool SetClearTileBlockedByTargetUnitFlag;
+	// Spawn on the target's own tile.
 	var bool ClearTileBlockedByTargetUnitFlag;
 
 	// X2Effect_SpawnUnit
 	var bool SetCopyTargetAppearance;
+	// Give the spawned unit the target's appearance. Takes precedence over CopySourceAppearance.
 	var bool CopyTargetAppearance;
 
 	// X2Effect_SpawnUnit
 	var bool SetCopySourceAppearance;
+	// Give the spawned unit the source's appearance.
 	var bool CopySourceAppearance;
 
 	// X2Effect_SpawnUnit
 	var bool SetKnockbackAffectsSpawnLocation;
+	// Spawn where the target ended up after knockback rather than where it was hit.
 	var bool KnockbackAffectsSpawnLocation;
 
 	// X2Effect_SpawnUnit
 	var bool SetAddToSourceGroup;
+	// Put the spawned unit in the source's AI group.
 	var bool AddToSourceGroup;
 
 	// X2Effect_SpawnUnit
 	var bool SetCopyReanimatedFromUnit;
+	// Copy the reanimated unit's inventory and abilities too, not just its appearance.
 	var bool CopyReanimatedFromUnit;
 
 	// X2Effect_SpawnUnit
 	var bool SetCopyReanimatedStatsFromUnit;
+	// Copy the reanimated unit's stats.
 	var bool CopyReanimatedStatsFromUnit;
 
 	// X2Effect_SpawnUnit
 	var bool SetSetProcessedScamperAs;
+	// Mark the spawned unit's group as having already scampered, so it does not reveal and scamper on sight.
 	var bool SetProcessedScamperAs;
 
 	// X2Effect_Spotted
 	var bool SetBecomeUnspotted;
+	// Mark the unit as unspotted instead of spotted.
 	var bool BecomeUnspotted;
 
 	// X2Effect_Stasis
 	var bool SetStunStartAnim;
+	// Animation played when stasis starts.
 	var name StunStartAnim;
 
 	// X2Effect_Stasis
 	var bool SetStunStopAnim;
+	// Animation played when stasis ends.
 	var name StunStopAnim;
 
 	// X2Effect_Stasis
 	var bool SetSkipFlyover;
+	// Skip the flyover text.
 	var bool SkipFlyover;
 
 	// X2Effect_Stasis
 	var bool SetStartAnimBlendTime;
+	// Blend time, in seconds, into the start animation.
 	var float StartAnimBlendTime;
 
 	// X2Effect_SuperConcealModifier
 	var bool SetConcealAmountScalar;
+	// Multiplier on the base chance of losing super concealment, added to the modifier.
 	var float ConcealAmountScalar;
 
 	// X2Effect_SuperConcealModifier
 	var ENameArrayEditMode AbilitiesAffectedFilterMode;
+	// Abilities the modifier applies to. Empty means every ability.
 	var array<name> AbilitiesAffectedFilter;
 
 	// X2Effect_SuperConcealModifier
 	var ENameArrayEditMode RemoveOnAbilityActivationMode;
+	// Abilities whose activation removes the effect.
 	var array<name> RemoveOnAbilityActivation;
 
 	// X2Effect_SuspendMissionTimer
 	var bool SetResumeMissionTimer;
+	// Resume the mission timer instead of suspending it.
 	var bool ResumeMissionTimer;
 
 	// X2Effect_TalonRounds
 	var bool SetAimMod;
+	// Aim added.
 	var int AimMod;
 
 	// X2Effect_TargetDamageDistanceBonus, X2Effect_TargetDamageTypeBonus
 	var bool SetBonusDmgFloat;
+	// Bonus damage: a flat amount with MODOP_Addition, or a multiplier on the damage with MODOP_Multiplication.
 	var float BonusDmgFloat;
 
 	// X2Effect_TargetDamageDistanceBonus, X2Effect_TargetDamageTypeBonus
 	var bool SetBonusModType;
+	// How BonusDmgFloat is applied: MODOP_Addition or MODOP_Multiplication.
 	var EStatModOp BonusModType;
 
 	// X2Effect_TargetDamageDistanceBonus
 	var bool SetWithinTileDistance;
+	// Farthest distance to the target, in tiles, at which the bonus applies.
 	var int WithinTileDistance;
 
 	// X2Effect_TargetDamageDistanceBonus
 	var bool SetPrimaryTargetOnly;
+	// Only apply to the attack's primary target.
 	var bool PrimaryTargetOnly;
 
 	// X2Effect_TargetDamageTypeBonus
 	var ENameArrayEditMode BonusDamageTypesMode;
+	// Damage types the bonus applies to.
 	var array<name> BonusDamageTypes;
 
 	// X2Effect_ThreatAssessment
 	var bool SetImmediateActionPoint;
+	// Reserve action point given to the target as soon as the effect is applied.
 	var name ImmediateActionPoint;
 
+	// X2Effect_TemplarFocus (merged by position: entry N is focus level N)
+	var ENameArrayEditMode FocusLevelsMode;
+	// One entry per focus level from level 0: the stat changes, armor mitigation and bonus weapon damage granted at that level. Merge overwrites the level at the same position or appends it.
+	var array<FocusLevelModifiers> FocusLevels;
+
 	// X2Effect_ToHitModifier
 	var bool SetApplyAsTarget;
+	// Apply the modifiers to attacks against the unit rather than attacks it makes.
 	var bool ApplyAsTarget;
 
 	// X2Effect_TrackingShotMarkTarget
 	var bool SetConeLength;
+	// Length of the marked cone from the source to the target.
 	var float ConeLength;
 
 	// X2Effect_TrackingShotMarkTarget
 	var bool SetConeEndDiameter;
+	// Diameter of the marked cone at its far end.
 	var float ConeEndDiameter;
 
 	// X2Effect_TriggerEvent
 	var bool SetPassTargetAsSource;
+	// Fire the event with the target as its source.
 	var bool PassTargetAsSource;
 
 	// X2Effect_TurnStartActionPoints
 	var bool SetActionPointType;
+	// Type of action point added, or removed, at the start of the turn.
 	var name ActionPointType;
 
 	// X2Effect_TurnStartActionPoints
 	var bool SetActionPointsRemoved;
+	// Remove the action points instead of adding them.
 	var bool ActionPointsRemoved;
 
 	// X2Effect_VanishingWind
 	var bool SetMovingVanishRevealAdditiveAnimName;
+	// Additive animation played on reveal when the unit is revealed while moving.
 	var name MovingVanishRevealAdditiveAnimName;
 
 	// X2Effect_VoidConduit
 	var bool SetDamagePerAction;
+	// Damage dealt for each action point stolen.
 	var int DamagePerAction;
 
 	// X2Effect_VoidConduit
 	var bool SetHealthReturnMod;
+	// Fraction of the damage dealt that is returned to the source as health.
 	var float HealthReturnMod;
 
 	// X2Effect_WallBreaking
 	var bool SetWallBreakingEffectName;
+	// Name of the effect on the unit that grants wall breaking.
 	var name WallBreakingEffectName;
 
 	// X2Effect_World
 	var bool SetCenterTile;
+	// Apply the world effect to the centre tile only.
 	var bool CenterTile;
 
 	// X2Effect_PersistentStatChangeRestoreDefault
 	var ENameArrayEditMode StatTypesToRestoreMode;
+	// Stats reset to their default value while the effect lasts.
 	var array<ECharStatType> StatTypesToRestore;
 
 	// X2Effect_ConditionalDamageModifier
@@ -1654,76 +2233,98 @@ struct ToHitCalcEdit
 
 	// X2AbilityToHitCalc_StandardAim
 	var bool SetIndirectFire;
+	// Treats the attack as indirect, like a grenade: it always hits, though crit, dodge and armour mitigation still apply.
 	var bool IndirectFire;
 
 	var bool SetMeleeAttack;
+	// Treats the attack as melee, which ignores cover and applies the intrinsic melee hit bonus.
 	var bool MeleeAttack;
 
 	var bool SetReactionFire;
+	// Treats the attack as reaction fire, which takes the reaction penalty and forgoes the flanking bonus.
 	var bool ReactionFire;
 
 	var bool SetAllowCrit;
+	// Whether crits are built into the hit table at all. Turning it off makes the ability incapable of critting.
 	var bool AllowCrit;
 
 	var bool SetHitsAreCrits;
+	// Converts every successful hit into a crit after the roll is made.
 	var bool HitsAreCrits;
 
 	var bool SetMultiTargetOnly;
+	// Guarantees success when the ability has no primary target, for abilities that only ever hit multi-targets.
 	var bool MultiTargetOnly;
 
 	var bool SetOnlyMultiHitWithSuccess;
+	// Multi-target hits only land if the roll succeeded, as with Faceoff.
 	var bool OnlyMultiHitWithSuccess;
 
 	var bool SetGuaranteedHit;
+	// Always hits, skipping the normal hit modifiers. Armour mitigation still rolls.
 	var bool GuaranteedHit;
 
 	var bool SetIgnoreCoverBonus;
+	// Ignores the target's high and low cover bonuses.
 	var bool IgnoreCoverBonus;
 
 	var bool SetFinalMultiplier;
+	// Scales the final hit chance after everything else. Appears in the shot breakdown attributed to the ability.
 	var float FinalMultiplier;
 
 	var bool SetBuiltInHitMod;
+	// Flat aim modifier the ability always carries.
 	var int BuiltInHitMod;
 
 	var bool SetBuiltInCritMod;
+	// Flat crit modifier the ability always carries.
 	var int BuiltInCritMod;
 
 	// X2AbilityToHitCalc_PercentChance
 	var bool SetPercentToHit;
+	// Flat percentage chance to hit, ignoring aim entirely. For abilities whose odds are fixed rather than calculated.
 	var int PercentToHit;
 
 	var bool SetNoGameStateOnMiss;
+	// Produces no game state at all on a miss, so nothing is recorded or visualised.
 	var bool NoGameStateOnMiss;
 
 	// X2AbilityToHitCalc_PercentChancePlusFocus
 	var bool SetFocusMultiplier;
+	// Percentage points added to the hit chance per point of Templar focus.
 	var int FocusMultiplier;
 
 	// X2AbilityToHitCalc_PercentChanceWithBuddyZone
 	var bool SetPercentToHitInBuddyZone;
+	// Replaces PercentToHit when the target is inside the buddy zone.
 	var int PercentToHitInBuddyZone;
 
 	// X2AbilityToHitCalc_Hacking
 	var bool SetAlwaysSucceed;
+	// Makes the hack always succeed.
 	var bool AlwaysSucceed;
 
 	// X2AbilityToHitCalc_RollStat, X2AbilityToHitCalc_RollStatTiers
 	var bool SetStatToRoll;
+	// Which unit stat the roll is made against.
 	var ECharStatType StatToRoll;
 
 	var bool SetBaseChance;
+	// Base percentage before the stat is taken into account.
 	var int BaseChance;
 
 	// X2AbilityToHitCalc_StatCheck
 	var bool SetBaseValue;
+	// Base value the stat contest is measured against.
 	var int BaseValue;
 
 	// X2AbilityToHitCalc_StatCheck_UnitVsUnit
 	var bool SetAttackerStat;
+	// Attacker's stat in a unit-versus-unit contest.
 	var ECharStatType AttackerStat;
 
 	var bool SetDefenderStat;
+	// Defender's stat in a unit-versus-unit contest.
 	var ECharStatType DefenderStat;
 
 	var array<AECustomProperty> CustomProperties;
@@ -1737,35 +2338,45 @@ struct TargetStyleEdit
 
 	// X2AbilityTarget_Single
 	var bool SetOnlyIncludeTargetsInsideWeaponRange;
+	// Excludes targets beyond the weapon's range from selection.
 	var bool OnlyIncludeTargetsInsideWeaponRange;
 
 	var bool SetAllowInteractiveObjects;
+	// Lets the ability target interactive objects such as doors and consoles.
 	var bool AllowInteractiveObjects;
 
 	var bool SetAllowDestructibleObjects;
+	// Lets the ability target destructible scenery.
 	var bool AllowDestructibleObjects;
 
 	var bool SetIncludeSelf;
+	// Lets the user target itself.
 	var bool IncludeSelf;
 
 	var bool SetShowAOE;
+	// Draws the area-of-effect preview while aiming.
 	var bool ShowAOE;
 
 	// X2AbilityTarget_Cursor
 	var bool SetRestrictToWeaponRange;
+	// Limits the cursor to the weapon's range.
 	var bool RestrictToWeaponRange;
 
 	var bool SetIncreaseWeaponRange;
+	// Extra range in tiles beyond the weapon's own, when restricted to weapon range.
 	var int IncreaseWeaponRange;
 
 	var bool SetRestrictToSquadsightRange;
+	// Limits the cursor to squadsight range rather than the weapon's.
 	var bool RestrictToSquadsightRange;
 
 	var bool SetFixedAbilityRange;
+	// Fixed range in tiles, ignoring the weapon entirely.
 	var int FixedAbilityRange;
 
 	// X2AbilityTarget_MovingMelee
 	var bool SetMovementRangeAdjustment;
+	// Tiles added to or removed from how far the unit may move to reach a melee target.
 	var int MovementRangeAdjustment;
 
 	var array<AECustomProperty> CustomProperties;
@@ -1779,115 +2390,150 @@ struct MultiTargetStyleEdit
 
 	// X2AbilityMultiTargetStyle (shared)
 	var bool SetAllowSameTarget;
+	// Lets the primary target also be picked up as a multi-target.
 	var bool AllowSameTarget;
 
 	var bool SetUseSourceWeaponLocation;
+	// Measures the area from the shooter's weapon rather than the unit.
 	var bool UseSourceWeaponLocation;
 
 	var bool SetNumTargetsRequired;
+	// Minimum targets that must be in the area for the ability to be usable.
 	var int NumTargetsRequired;
 
 	// X2AbilityMultiTarget_Radius
 	var bool SetUseWeaponRadius;
+	// Takes the radius from the weapon. TargetRadius is then added on top.
 	var bool UseWeaponRadius;
 
 	var bool SetUseWeaponBlockingCoverFlag;
+	// Takes the weapon's setting for whether cover blocks the area.
 	var bool UseWeaponBlockingCoverFlag;
 
 	var bool SetIgnoreBlockingCover;
+	// Lets the area pass through cover that would otherwise block it.
 	var bool IgnoreBlockingCover;
 
 	var bool SetTargetRadius;
+	// Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.
 	var float TargetRadius;
 
 	var bool SetTargetCoveragePercentage;
+	// How much of a tile the area must cover before that tile counts as affected.
 	var float TargetCoveragePercentage;
 
 	var bool SetAddPrimaryTargetAsMultiTarget;
+	// Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.
 	var bool AddPrimaryTargetAsMultiTarget;
 
 	var bool SetAllowDeadMultiTargetUnits;
+	// Includes already-dead units in the area.
 	var bool AllowDeadMultiTargetUnits;
 
 	var bool SetExcludeSelfAsTargetIfWithinRadius;
+	// Leaves the user out of its own area of effect.
 	var bool ExcludeSelfAsTargetIfWithinRadius;
 
 	// merged by RequiredAbility
 	var ENameArrayEditMode AbilityBonusRadiiMode;
+	// Extra radius granted when the unit has a particular ability, merged by
+	// RequiredAbility. Lets a perk widen the blast without a separate ability.
 	var array<AbilityGrantedBonusRadius> AbilityBonusRadii;
 
 	// X2AbilityMultiTarget_Cone
 	var bool SetConeEndDiameter;
+	// Width of the cone at its far end, in metres.
 	var float ConeEndDiameter;
 
 	var bool SetConeLength;
+	// How far the cone reaches, in metres.
 	var float ConeLength;
 
 	var bool SetUseWeaponRangeForLength;
+	// Takes the cone's length from the weapon's range instead of ConeLength.
 	var bool UseWeaponRangeForLength;
 
 	var bool SetLockShooterZ;
+	// Restricts the cone to tiles at the shooter's own height, so it does not spread up or down floors.
 	var bool LockShooterZ;
 
 	// merged by RequiredAbility
 	var ENameArrayEditMode AbilityBonusConesMode;
+	// Extra cone length and width granted by a particular ability, merged by RequiredAbility.
 	var array<AbilityGrantedBonusCone> AbilityBonusCones;
 
 	// X2AbilityMultiTarget_Line
 	var bool SetTileWidthExtension;
+	// Extra tiles of width added to the line.
 	var int TileWidthExtension;
 
 	var bool SetSightRangeLimited;
+	// Stops the line at the limit of sight.
 	var bool SightRangeLimited;
 
 	// merged by RequiredAbility
 	var ENameArrayEditMode AbilityBonusWidthsMode;
+	// Extra line width granted by a particular ability, merged by RequiredAbility.
 	var array<AbilityGrantedBonusWidth> AbilityBonusWidths;
 
 	// X2AbilityMultiTarget_Cylinder
 	var bool SetTargetHeight;
+	// Height of the cylinder in metres.
 	var float TargetHeight;
 
 	var bool SetUseOnlyGroundTiles;
+	// Restricts the cylinder to ground-level tiles.
 	var bool UseOnlyGroundTiles;
 
 	// X2AbilityMultiTarget_BurstFire
 	var bool SetNumExtraShots;
+	// Additional shots fired at the same target beyond the first.
 	var int NumExtraShots;
 
 	// X2AbilityMultiTarget_AllUnits
 	var bool SetOnlyAllyOfType;
+	// Restricts targeting to allies of this character type.
 	var name OnlyAllyOfType;
 
 	var bool SetAcceptFriendlyUnits;
+	// Includes friendly units.
 	var bool AcceptFriendlyUnits;
 
 	var bool SetAcceptEnemyUnits;
+	// Includes hostile units.
 	var bool AcceptEnemyUnits;
 
 	var bool SetOnlyAcceptRoboticUnits;
+	// Restricts targeting to robotic units.
 	var bool OnlyAcceptRoboticUnits;
 
 	var bool SetOnlyAcceptAlienUnits;
+	// Restricts targeting to aliens.
 	var bool OnlyAcceptAlienUnits;
 
 	var bool SetOnlyAcceptAdventUnits;
+	// Restricts targeting to ADVENT units.
 	var bool OnlyAcceptAdventUnits;
 
 	var bool SetRandomlySelectOne;
+	// Picks a single target at random from everything that qualified.
 	var bool RandomlySelectOne;
 
 	var bool SetDontAcceptNeutralUnits;
+	// Leaves civilians and other neutrals out.
 	var bool DontAcceptNeutralUnits;
 
 	var bool SetRandomChance;
+	// Percentage chance each qualifying unit is actually included.
 	var int RandomChance;
 
 	var bool SetUseAbilitySourceAsPrimaryTarget;
+	// Treats the ability's user as the primary target.
 	var bool UseAbilitySourceAsPrimaryTarget;
 
 	// X2AbilityMultiTarget_ClaymoreRadius
 	var bool SetClaymoreEnvironmentalDamage;
+	// Environmental damage the claymore blast does to scenery.
 	var int ClaymoreEnvironmentalDamage;
 
 	var array<AECustomProperty> CustomProperties;
@@ -1903,27 +2549,35 @@ struct TriggerEdit
 
 	// X2AbilityTrigger_UnitPostBeginPlay
 	var bool SetPriority;
+	// Order this trigger runs in relative to others on the same event. Lower runs first.
 	var int Priority;
 
 	// X2AbilityTrigger_EventListener (ListenerData members; EventFn cannot be set from config)
 	var bool SetListenerEventID;
+	// Event this listener waits for. The handling function can only be assigned in code,
+	// so a listener added purely from config never fires - editing an existing one does.
 	var name ListenerEventID;
 
 	var bool SetListenerDeferral;
+	// When the listener runs relative to the event being processed.
 	var EventListenerDeferral ListenerDeferral;
 
 	var bool SetListenerFilter;
+	// Which units the event is accepted from, such as only the source or only the target.
 	var AbilityEventFilter ListenerFilter;
 
 	var bool SetListenerPriority;
+	// Order among listeners for the same event.
 	var int ListenerPriority;
 
 	// X2AbilityTrigger_Event
 	var bool SetMethodName;
+	// Method on the observer class that the trigger calls.
 	var name MethodName;
 
 	// Class path loaded via DynamicLoadObject
 	var bool SetEventObserverClass;
+	// Class that observes the event. Loaded by name at runtime.
 	var string EventObserverClass;
 
 	var array<AECustomProperty> CustomProperties;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityChargesEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityChargesEditor_Helper.uc
index e050b91..d953d42 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityChargesEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityChargesEditor_Helper.uc
@@ -89,7 +89,8 @@ static function DispatchChargesEdit(name AbilityName, X2AbilityCharges AbilityCh
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.ChargesEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.ChargesEditors[i].static.CanEdit(AbilityCharges))
+		if (class'X2DLCInfo_AbilityEditor'.default.ChargesEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.ChargesEditors[i].static.CanEdit(AbilityCharges))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.ChargesEditors[i].static.ApplyEdit(AbilityName, AbilityCharges, ChargesEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_GameTime.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_GameTime.uc
new file mode 100644
index 0000000..770ae90
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_GameTime.uc
@@ -0,0 +1,31 @@
+class X2AbilityConditionEditor_GameTime extends X2AbilityConditionEditor_Base;
+
+static function bool CanEdit(X2Condition Condition)
+{
+	return Condition.IsA('X2Condition_GameTime');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Condition Condition,
+	ConditionEdit ConditionEdit
+)
+{
+	local X2Condition_GameTime GameTimeCondition;
+
+	GameTimeCondition = X2Condition_GameTime(Condition);
+
+	if (GameTimeCondition == none)
+	{
+		return;
+	}
+
+	class'X2AbilityConditionEditor_Helper'.static.ApplyCheckConfigArrayEdit(
+		AbilityName,
+		Slot $ ".HourChecks",
+		GameTimeCondition.HourChecks,
+		ConditionEdit.HourChecks,
+		ConditionEdit.HourChecksMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_Helper.uc
index e2bb35d..9a66cb2 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityConditionEditor_Helper.uc
@@ -1,7 +1,5 @@
 class X2AbilityConditionEditor_Helper extends Object;
 
-// Applies a list of condition edits to a condition array
-// (template-level arrays or an effect's TargetConditions).
 static function ApplyConditionEdits(
 	name AbilityName,
 	string Slot,
@@ -142,7 +140,8 @@ static function DispatchConditionEdit(
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.ConditionEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.ConditionEditors[i].static.CanEdit(Condition))
+		if (class'X2DLCInfo_AbilityEditor'.default.ConditionEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.ConditionEditors[i].static.CanEdit(Condition))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.ConditionEditors[i].static.ApplyEdit(
 				AbilityName,
@@ -229,6 +228,94 @@ static function ApplyEffectReasonArrayEdit(
 	}
 }
 
+static function ApplyCheckConfigArrayEdit(
+	name AbilityName,
+	string Category,
+	out array<CheckConfig> Target,
+	array<CheckConfig> EditValues,
+	ENameArrayEditMode Mode
+)
+{
+	local int i, Index;
+
+	if (EditValues.Length == 0)
+	{
+		return;
+	}
+
+	switch (Mode)
+	{
+		case eNAEM_Replace:
+			`log(string(AbilityName) @ Category @ "replaced", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+			Target = EditValues;
+			break;
+
+		case eNAEM_AddOnly:
+			if (Target.Length == 0)
+			{
+				`log(string(AbilityName) @ Category @ "set", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+				Target = EditValues;
+			}
+			break;
+
+		case eNAEM_Merge:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				Index = FindCheckConfigIndex(Target, EditValues[i]);
+
+				if (Index == INDEX_NONE)
+				{
+					class'X2AbilityEditor_Logger'.static.LogInfo(
+						AbilityName,
+						Category,
+						"none",
+						DescribeCheckConfig(EditValues[i])
+					);
+					Target.AddItem(EditValues[i]);
+				}
+			}
+			break;
+
+		case eNAEM_Remove:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				Index = FindCheckConfigIndex(Target, EditValues[i]);
+
+				if (Index != INDEX_NONE)
+				{
+					class'X2AbilityEditor_Logger'.static.LogInfo(
+						AbilityName,
+						Category,
+						DescribeCheckConfig(EditValues[i]),
+						"none"
+					);
+					Target.Remove(Index, 1);
+				}
+			}
+			break;
+	}
+}
+
+static function int FindCheckConfigIndex(const out array<CheckConfig> Entries, CheckConfig Check)
+{
+	local int i;
+
+	for (i = 0; i < Entries.Length; ++i)
+	{
+		if (Entries[i] == Check)
+		{
+			return i;
+		}
+	}
+
+	return INDEX_NONE;
+}
+
+static function string DescribeCheckConfig(CheckConfig Check)
+{
+	return string(Check.CheckType) $ "(" $ Check.Value $ "," $ Check.ValueMin $ "," $ Check.ValueMax $ ")";
+}
+
 static function int FindEffectReasonIndex(const out array<EffectReason> Entries, name EffectName)
 {
 	local int i;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCooldownEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCooldownEditor_Helper.uc
index 4150566..74eb05d 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCooldownEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCooldownEditor_Helper.uc
@@ -82,7 +82,8 @@ static function DispatchCooldownEdit(name AbilityName, X2AbilityCooldown Ability
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.CooldownEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.CooldownEditors[i].static.CanEdit(AbilityCooldown))
+		if (class'X2DLCInfo_AbilityEditor'.default.CooldownEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.CooldownEditors[i].static.CanEdit(AbilityCooldown))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.CooldownEditors[i].static.ApplyEdit(AbilityName, AbilityCooldown, CooldownEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCostEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCostEditor_Helper.uc
index 3d06053..0f17c38 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCostEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityCostEditor_Helper.uc
@@ -109,7 +109,8 @@ static function DispatchCostEdit(name AbilityName, X2AbilityCost AbilityCost, Co
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.CostEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.CostEditors[i].static.CanEdit(AbilityCost))
+		if (class'X2DLCInfo_AbilityEditor'.default.CostEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.CostEditors[i].static.CanEdit(AbilityCost))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.CostEditors[i].static.ApplyEdit(AbilityName, AbilityCost, CostEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEditor_Helper.uc
index 573613b..d8b8969 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEditor_Helper.uc
@@ -72,6 +72,235 @@ static function ApplyNameArrayEdit(name AbilityName, string Category, out array<
 	}
 }
 
+// Merge/Remove are keyed by UnitValueName.
+static function ApplyRecordDataArrayEdit(
+	name AbilityName,
+	string Category,
+	out array<RecordData> Target,
+	array<RecordData> EditValues,
+	ENameArrayEditMode Mode
+)
+{
+	local int i, Index;
+
+	if (EditValues.Length == 0)
+	{
+		return;
+	}
+
+	switch (Mode)
+	{
+		case eNAEM_Replace:
+			`log(string(AbilityName) @ Category @ "replaced", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+			Target = EditValues;
+			break;
+
+		case eNAEM_AddOnly:
+			if (Target.Length == 0)
+			{
+				`log(string(AbilityName) @ Category @ "set", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+				Target = EditValues;
+			}
+			break;
+
+		case eNAEM_Merge:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				Index = FindRecordDataIndex(Target, EditValues[i].UnitValueName);
+
+				if (Index == INDEX_NONE)
+				{
+					class'X2AbilityEditor_Logger'.static.LogInfo(
+						AbilityName,
+						Category,
+						"none",
+						string(EditValues[i].UnitValueName)
+					);
+					Target.AddItem(EditValues[i]);
+				}
+				else
+				{
+					Target[Index] = EditValues[i];
+				}
+			}
+			break;
+
+		case eNAEM_Remove:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				Index = FindRecordDataIndex(Target, EditValues[i].UnitValueName);
+
+				if (Index != INDEX_NONE)
+				{
+					class'X2AbilityEditor_Logger'.static.LogInfo(
+						AbilityName,
+						Category,
+						string(EditValues[i].UnitValueName),
+						"none"
+					);
+					Target.Remove(Index, 1);
+				}
+			}
+			break;
+	}
+}
+
+static function int FindRecordDataIndex(const out array<RecordData> Entries, name UnitValueName)
+{
+	local int i;
+
+	for (i = 0; i < Entries.Length; ++i)
+	{
+		if (Entries[i].UnitValueName == UnitValueName)
+		{
+			return i;
+		}
+	}
+
+	return INDEX_NONE;
+}
+
+// Merge/Remove are keyed by AbilityName.
+static function ApplyAdditionalSuccessModifierArrayEdit(
+	name AbilityName,
+	string Category,
+	out array<AdditionalSuccessModifier> Target,
+	array<AdditionalSuccessModifier> EditValues,
+	ENameArrayEditMode Mode
+)
+{
+	local int i, Index;
+
+	if (EditValues.Length == 0)
+	{
+		return;
+	}
+
+	switch (Mode)
+	{
+		case eNAEM_Replace:
+			`log(string(AbilityName) @ Category @ "replaced", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+			Target = EditValues;
+			break;
+
+		case eNAEM_AddOnly:
+			if (Target.Length == 0)
+			{
+				`log(string(AbilityName) @ Category @ "set", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+				Target = EditValues;
+			}
+			break;
+
+		case eNAEM_Merge:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				Index = FindAdditionalSuccessModifierIndex(Target, EditValues[i].AbilityName);
+
+				if (Index == INDEX_NONE)
+				{
+					class'X2AbilityEditor_Logger'.static.LogInfo(
+						AbilityName,
+						Category,
+						"none",
+						string(EditValues[i].AbilityName)
+					);
+					Target.AddItem(EditValues[i]);
+				}
+				else
+				{
+					Target[Index] = EditValues[i];
+				}
+			}
+			break;
+
+		case eNAEM_Remove:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				Index = FindAdditionalSuccessModifierIndex(Target, EditValues[i].AbilityName);
+
+				if (Index != INDEX_NONE)
+				{
+					class'X2AbilityEditor_Logger'.static.LogInfo(
+						AbilityName,
+						Category,
+						string(EditValues[i].AbilityName),
+						"none"
+					);
+					Target.Remove(Index, 1);
+				}
+			}
+			break;
+	}
+}
+
+static function int FindAdditionalSuccessModifierIndex(const out array<AdditionalSuccessModifier> Entries, name AbilityName)
+{
+	local int i;
+
+	for (i = 0; i < Entries.Length; ++i)
+	{
+		if (Entries[i].AbilityName == AbilityName)
+		{
+			return i;
+		}
+	}
+
+	return INDEX_NONE;
+}
+
+// Merge is positional: entry N overwrites focus level N, or appends it. Remove has no key to act on.
+static function ApplyFocusLevelModifiersArrayEdit(
+	name AbilityName,
+	string Category,
+	out array<FocusLevelModifiers> Target,
+	array<FocusLevelModifiers> EditValues,
+	ENameArrayEditMode Mode
+)
+{
+	local int i;
+
+	if (EditValues.Length == 0)
+	{
+		return;
+	}
+
+	switch (Mode)
+	{
+		case eNAEM_Replace:
+			`log(string(AbilityName) @ Category @ "replaced", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+			Target = EditValues;
+			break;
+
+		case eNAEM_AddOnly:
+			if (Target.Length == 0)
+			{
+				`log(string(AbilityName) @ Category @ "set", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+				Target = EditValues;
+			}
+			break;
+
+		case eNAEM_Merge:
+			for (i = 0; i < EditValues.Length; ++i)
+			{
+				if (i < Target.Length)
+				{
+					`log(string(AbilityName) @ Category $ "[" $ i $ "]" @ "replaced", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+					Target[i] = EditValues[i];
+				}
+				else
+				{
+					`log(string(AbilityName) @ Category $ "[" $ i $ "]" @ "added", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+					Target.AddItem(EditValues[i]);
+				}
+			}
+			break;
+
+		case eNAEM_Remove:
+			`log(string(AbilityName) @ Category @ "eNAEM_Remove is not supported for focus levels; use eNAEM_Replace", class'X2DLCInfo_AbilityEditor'.default.EnableDebug, 'AbilityEditor');
+			break;
+	}
+}
+
 // Same semantics as ApplyNameArrayEdit, for string arrays.
 static function ApplyStringArrayEdit(name AbilityName, string Category, out array<string> Target, array<string> EditValues, ENameArrayEditMode Mode)
 {
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_AlertTheLost.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_AlertTheLost.uc
new file mode 100644
index 0000000..4bf87d5
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_AlertTheLost.uc
@@ -0,0 +1,35 @@
+class X2AbilityEffectsEditor_AlertTheLost extends X2AbilityEffectsEditor_Base;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_AlertTheLost');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_AlertTheLost AlertTheLostEffect;
+
+	AlertTheLostEffect = X2Effect_AlertTheLost(Effect);
+
+	if (AlertTheLostEffect == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetAlertRangeMeters)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AlertRangeMeters",
+			string(AlertTheLostEffect.AlertRangeMeters),
+			string(EffectEdit.AlertRangeMeters)
+		);
+
+		AlertTheLostEffect.AlertRangeMeters = EffectEdit.AlertRangeMeters;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyAcidToWorld.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyAcidToWorld.uc
new file mode 100644
index 0000000..95f46d8
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyAcidToWorld.uc
@@ -0,0 +1,157 @@
+class X2AbilityEffectsEditor_ApplyAcidToWorld extends X2AbilityEffectsEditor_World;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_ApplyAcidToWorld');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_ApplyAcidToWorld ApplyAcidToWorldFX;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	ApplyAcidToWorldFX = X2Effect_ApplyAcidToWorld(Effect);
+
+	if (ApplyAcidToWorldFX == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem1Tile)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_1pc",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_1pc,
+			EffectEdit.AcidParticleSystem1Tile
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_1pc = EffectEdit.AcidParticleSystem1Tile;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem2Tiles)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_2pc",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_2pc,
+			EffectEdit.AcidParticleSystem2Tiles
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_2pc = EffectEdit.AcidParticleSystem2Tiles;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem3TilesLine)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_3pc_Long",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_3pc_Long,
+			EffectEdit.AcidParticleSystem3TilesLine
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_3pc_Long = EffectEdit.AcidParticleSystem3TilesLine;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem3TilesCorner)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_3pc_Corner",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_3pc_Corner,
+			EffectEdit.AcidParticleSystem3TilesCorner
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_3pc_Corner = EffectEdit.AcidParticleSystem3TilesCorner;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesLine)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_Long",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Long,
+			EffectEdit.AcidParticleSystem4TilesLine
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Long = EffectEdit.AcidParticleSystem4TilesLine;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesSquare)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_Square",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Square,
+			EffectEdit.AcidParticleSystem4TilesSquare
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Square = EffectEdit.AcidParticleSystem4TilesSquare;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesL)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_L",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_L,
+			EffectEdit.AcidParticleSystem4TilesL
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_L = EffectEdit.AcidParticleSystem4TilesL;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesReverseL)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_Reverse_L",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Reverse_L,
+			EffectEdit.AcidParticleSystem4TilesReverseL
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Reverse_L = EffectEdit.AcidParticleSystem4TilesReverseL;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesT)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_Middle",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Middle,
+			EffectEdit.AcidParticleSystem4TilesT
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Middle = EffectEdit.AcidParticleSystem4TilesT;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesS)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_S",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_S,
+			EffectEdit.AcidParticleSystem4TilesS
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_S = EffectEdit.AcidParticleSystem4TilesS;
+	}
+
+	if (EffectEdit.SetAcidParticleSystem4TilesReverseS)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".AcidParticleSystemFill_Name_4pc_Reverse_S",
+			ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Reverse_S,
+			EffectEdit.AcidParticleSystem4TilesReverseS
+		);
+
+		ApplyAcidToWorldFX.AcidParticleSystemFill_Name_4pc_Reverse_S = EffectEdit.AcidParticleSystem4TilesReverseS;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld.uc
index 5ff5fe2..5f554a4 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld.uc
@@ -23,15 +23,15 @@ static function ApplyDerivedEdit(
 		return;
 	}
 
-	if (EffectEdit.SetOverrideParticleSystemFill_Name)
+	if (EffectEdit.SetOverrideParticleSystem)
 	{
 		class'X2AbilityEditor_Logger'.static.LogInfo(
 			AbilityName,
 			Slot $ ".OverrideParticleSystemFill_Name",
 			ApplyBlazingPinionsTargetToWorldFX.OverrideParticleSystemFill_Name,
-			EffectEdit.OverrideParticleSystemFill_Name
+			EffectEdit.OverrideParticleSystem
 		);
 
-		ApplyBlazingPinionsTargetToWorldFX.OverrideParticleSystemFill_Name = EffectEdit.OverrideParticleSystemFill_Name;
+		ApplyBlazingPinionsTargetToWorldFX.OverrideParticleSystemFill_Name = EffectEdit.OverrideParticleSystem;
 	}
 }
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyPoisonToWorld.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyPoisonToWorld.uc
new file mode 100644
index 0000000..d279611
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplyPoisonToWorld.uc
@@ -0,0 +1,37 @@
+class X2AbilityEffectsEditor_ApplyPoisonToWorld extends X2AbilityEffectsEditor_World;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_ApplyPoisonToWorld');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_ApplyPoisonToWorld ApplyPoisonToWorldFX;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	ApplyPoisonToWorldFX = X2Effect_ApplyPoisonToWorld(Effect);
+
+	if (ApplyPoisonToWorldFX == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetPoisonParticleSystem)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".PoisonParticleSystemFill_Name",
+			ApplyPoisonToWorldFX.PoisonParticleSystemFill_Name,
+			EffectEdit.PoisonParticleSystem
+		);
+
+		ApplyPoisonToWorldFX.PoisonParticleSystemFill_Name = EffectEdit.PoisonParticleSystem;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld.uc
new file mode 100644
index 0000000..6179aeb
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld.uc
@@ -0,0 +1,37 @@
+class X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld extends X2AbilityEffectsEditor_World;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_ApplySmokeGrenadeToWorld');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_ApplySmokeGrenadeToWorld ApplySmokeGrenadeToWorldFX;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	ApplySmokeGrenadeToWorldFX = X2Effect_ApplySmokeGrenadeToWorld(Effect);
+
+	if (ApplySmokeGrenadeToWorldFX == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetSmokeParticleSystem)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".SmokeParticleSystemFill_Name",
+			ApplySmokeGrenadeToWorldFX.SmokeParticleSystemFill_Name,
+			EffectEdit.SmokeParticleSystem
+		);
+
+		ApplySmokeGrenadeToWorldFX.SmokeParticleSystemFill_Name = EffectEdit.SmokeParticleSystem;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplySmokeToWorld.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplySmokeToWorld.uc
new file mode 100644
index 0000000..6a1ad0e
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ApplySmokeToWorld.uc
@@ -0,0 +1,37 @@
+class X2AbilityEffectsEditor_ApplySmokeToWorld extends X2AbilityEffectsEditor_World;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_ApplySmokeToWorld');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_ApplySmokeToWorld ApplySmokeToWorldFX;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	ApplySmokeToWorldFX = X2Effect_ApplySmokeToWorld(Effect);
+
+	if (ApplySmokeToWorldFX == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetSmokeParticleSystem)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".SmokeParticleSystemFill_Name",
+			ApplySmokeToWorldFX.SmokeParticleSystemFill_Name,
+			EffectEdit.SmokeParticleSystem
+		);
+
+		ApplySmokeToWorldFX.SmokeParticleSystemFill_Name = EffectEdit.SmokeParticleSystem;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_BondmateAimAdjust.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_BondmateAimAdjust.uc
new file mode 100644
index 0000000..8e463ec
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_BondmateAimAdjust.uc
@@ -0,0 +1,61 @@
+class X2AbilityEffectsEditor_BondmateAimAdjust extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_BondmateAimAdjust');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_BondmateAimAdjust BondmateAimEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	BondmateAimEffect = X2Effect_BondmateAimAdjust(Effect);
+
+	if (BondmateAimEffect == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetThreatenedBondmateAimBonus)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".ThreatenedBondmateAimBonus",
+			string(BondmateAimEffect.ThreatenedBondmateAimBonus),
+			string(EffectEdit.ThreatenedBondmateAimBonus)
+		);
+
+		BondmateAimEffect.ThreatenedBondmateAimBonus = EffectEdit.ThreatenedBondmateAimBonus;
+	}
+
+	if (EffectEdit.SetBondmateTargetAimBonus)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".BondmateTargetAimBonus",
+			string(BondmateAimEffect.BondmateTargetAimBonus),
+			string(EffectEdit.BondmateTargetAimBonus)
+		);
+
+		BondmateAimEffect.BondmateTargetAimBonus = EffectEdit.BondmateTargetAimBonus;
+	}
+
+	if (EffectEdit.SetBondmateTargetCritBonus)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".BondmateTargetCritBonus",
+			string(BondmateAimEffect.BondmateTargetCritBonus),
+			string(EffectEdit.BondmateTargetCritBonus)
+		);
+
+		BondmateAimEffect.BondmateTargetCritBonus = EffectEdit.BondmateTargetCritBonus;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_BondmateBleedout.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_BondmateBleedout.uc
new file mode 100644
index 0000000..140c7c1
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_BondmateBleedout.uc
@@ -0,0 +1,37 @@
+class X2AbilityEffectsEditor_BondmateBleedout extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_BondmateBleedout');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_BondmateBleedout BondmateBleedoutEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	BondmateBleedoutEffect = X2Effect_BondmateBleedout(Effect);
+
+	if (BondmateBleedoutEffect == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetBleedoutDurationAdjustment)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".BleedoutDurationAdjustment",
+			string(BondmateBleedoutEffect.BleedoutDurationAdjustment),
+			string(EffectEdit.BleedoutDurationAdjustment)
+		);
+
+		BondmateBleedoutEffect.BleedoutDurationAdjustment = EffectEdit.BleedoutDurationAdjustment;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ChryssalidBurrowedAttack.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ChryssalidBurrowedAttack.uc
new file mode 100644
index 0000000..331a2b4
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ChryssalidBurrowedAttack.uc
@@ -0,0 +1,37 @@
+class X2AbilityEffectsEditor_ChryssalidBurrowedAttack extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_ChryssalidBurrowedAttack');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_ChryssalidBurrowedAttack BurrowedAttackEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	BurrowedAttackEffect = X2Effect_ChryssalidBurrowedAttack(Effect);
+
+	if (BurrowedAttackEffect == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetNumActions)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".NumActions",
+			string(BurrowedAttackEffect.NumActions),
+			string(EffectEdit.NumActions)
+		);
+
+		BurrowedAttackEffect.NumActions = EffectEdit.NumActions;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_CombatStims.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_CombatStims.uc
new file mode 100644
index 0000000..515d6ee
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_CombatStims.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_CombatStims extends X2AbilityEffectsEditor_BonusArmor;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_CombatStims');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_CombatStims CombatStimsEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	CombatStimsEffect = X2Effect_CombatStims(Effect);
+
+	if (CombatStimsEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyNameArrayEdit(
+		AbilityName,
+		Slot $ ".DamageTypeImmunities",
+		CombatStimsEffect.DamageTypeImmunities,
+		EffectEdit.DamageTypeImmunities,
+		EffectEdit.DamageTypeImmunitiesMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_DeadeyeDamage.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_DeadeyeDamage.uc
new file mode 100644
index 0000000..0aa124f
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_DeadeyeDamage.uc
@@ -0,0 +1,37 @@
+class X2AbilityEffectsEditor_DeadeyeDamage extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_DeadeyeDamage');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_DeadeyeDamage DeadeyeDamageEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	DeadeyeDamageEffect = X2Effect_DeadeyeDamage(Effect);
+
+	if (DeadeyeDamageEffect == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetDamageMultiplier)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".DamageMultiplier",
+			string(DeadeyeDamageEffect.DamageMultiplier),
+			string(EffectEdit.DamageMultiplier)
+		);
+
+		DeadeyeDamageEffect.DamageMultiplier = EffectEdit.DamageMultiplier;
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Fortress.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Fortress.uc
new file mode 100644
index 0000000..208254d
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Fortress.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_Fortress extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_Fortress');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_Fortress FortressEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	FortressEffect = X2Effect_Fortress(Effect);
+
+	if (FortressEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyNameArrayEdit(
+		AbilityName,
+		Slot $ ".DamageImmunities",
+		FortressEffect.DamageImmunities,
+		EffectEdit.DamageImmunities,
+		EffectEdit.DamageImmunitiesMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_GrantActionPointsWithRecord.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_GrantActionPointsWithRecord.uc
new file mode 100644
index 0000000..2cef2ef
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_GrantActionPointsWithRecord.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_GrantActionPointsWithRecord extends X2AbilityEffectsEditor_GrantActionPoints;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_GrantActionPointsWithRecord');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_GrantActionPointsWithRecord GrantEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	GrantEffect = X2Effect_GrantActionPointsWithRecord(Effect);
+
+	if (GrantEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyRecordDataArrayEdit(
+		AbilityName,
+		Slot $ ".RecordUnitValueWithGrant",
+		GrantEffect.RecordUnitValueWithGrant,
+		EffectEdit.RecordUnitValueWithGrant,
+		EffectEdit.RecordUnitValueWithGrantMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Helper.uc
index cfd3c66..4e579b2 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Helper.uc
@@ -70,9 +70,108 @@ static function ApplyToEffectArray(
 		Effect = Effects[Index];
 	}
 
+	if (EffectEdit.ApplyOnTickClass != "")
+	{
+		Effect = ResolveTickChild(AbilityName, Effect, EffectEdit, Slot);
+
+		if (Effect == none)
+		{
+			return;
+		}
+	}
+
 	DispatchEffectEdit(AbilityName, Slot, Effect, EffectEdit);
 }
 
+static function X2Effect ResolveTickChild(
+	name AbilityName,
+	X2Effect ParentEffect,
+	EffectEdit EffectEdit,
+	out string Slot
+)
+{
+	local X2Effect_Persistent Persistent;
+	local class<X2Effect> ChildClass;
+	local X2Effect Child;
+	local string ParentSlot;
+	local int i, Matches, Found;
+
+	ParentSlot = Slot;
+	Persistent = X2Effect_Persistent(ParentEffect);
+
+	if (Persistent == none)
+	{
+		`log(
+			"AbilityEdit:" @ string(AbilityName) @ ParentSlot @
+			"ApplyOnTickClass is set but" @ string(ParentEffect.Class.Name) @
+			"is not an X2Effect_Persistent, so it has no ApplyOnTick list",
+			class'X2DLCInfo_AbilityEditor'.default.EnableDebug,
+			'AbilityEditor'
+		);
+		return none;
+	}
+
+	ChildClass = LoadEffectClass(EffectEdit.ApplyOnTickClass);
+
+	if (ChildClass == none)
+	{
+		return none;
+	}
+
+	Found = INDEX_NONE;
+	Matches = 0;
+
+	for (i = 0; i < Persistent.ApplyOnTick.Length; ++i)
+	{
+		if (Persistent.ApplyOnTick[i].Class == ChildClass)
+		{
+			if (Matches == EffectEdit.ApplyOnTickIndex)
+			{
+				Found = i;
+				break;
+			}
+
+			Matches++;
+		}
+	}
+
+	if (EffectEdit.ApplyOnTickMode == eAEM_Remove)
+	{
+		if (Found != INDEX_NONE)
+		{
+			`log(
+				string(AbilityName) @ ParentSlot $ ".ApplyOnTick[" $ Found $ "]" @
+				"removed:" @ string(ChildClass.Name),
+				class'X2DLCInfo_AbilityEditor'.default.EnableDebug,
+				'AbilityEditor'
+			);
+			Persistent.ApplyOnTick.Remove(Found, 1);
+		}
+		return none;
+	}
+
+	if (EffectEdit.ApplyOnTickMode == eAEM_ReplaceAll)
+	{
+		Persistent.ApplyOnTick.Length = 0;
+		Found = INDEX_NONE;
+	}
+
+	if (Found == INDEX_NONE)
+	{
+		Child = new ChildClass;
+		Persistent.ApplyOnTick.AddItem(Child);
+		Found = Persistent.ApplyOnTick.Length - 1;
+	}
+	else
+	{
+		Child = Persistent.ApplyOnTick[Found];
+	}
+
+	Slot = ParentSlot $ ".ApplyOnTick[" $ Found $ "]";
+
+	return Child;
+}
+
 static function class<X2Effect> LoadEffectClass(string ClassName)
 {
 	local string QualifiedName;
@@ -136,7 +235,8 @@ static function DispatchEffectEdit(
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.EffectsEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.EffectsEditors[i].static.CanEdit(Effect))
+		if (class'X2DLCInfo_AbilityEditor'.default.EffectsEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.EffectsEditors[i].static.CanEdit(Effect))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.EffectsEditors[i].static.ApplyEdit(
 				AbilityName,
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_MimicBeacon.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_MimicBeacon.uc
new file mode 100644
index 0000000..9e6c577
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_MimicBeacon.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_MimicBeacon extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_MimicBeacon');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_MimicBeacon MimicBeaconEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	MimicBeaconEffect = X2Effect_MimicBeacon(Effect);
+
+	if (MimicBeaconEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyNameArrayEdit(
+		AbilityName,
+		Slot $ ".ABILITIES_ALLOWED_TO_HIT",
+		MimicBeaconEffect.ABILITIES_ALLOWED_TO_HIT,
+		EffectEdit.AbilitiesAllowedToHit,
+		EffectEdit.AbilitiesAllowedToHitMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ModifyStatCheckSuccesses.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ModifyStatCheckSuccesses.uc
new file mode 100644
index 0000000..7c59cdb
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ModifyStatCheckSuccesses.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_ModifyStatCheckSuccesses extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_ModifyStatCheckSuccesses');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_ModifyStatCheckSuccesses StatCheckEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	StatCheckEffect = X2Effect_ModifyStatCheckSuccesses(Effect);
+
+	if (StatCheckEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyAdditionalSuccessModifierArrayEdit(
+		AbilityName,
+		Slot $ ".AdditionalSuccessModifiers",
+		StatCheckEffect.AdditionalSuccessModifiers,
+		EffectEdit.AdditionalSuccessModifiers,
+		EffectEdit.AdditionalSuccessModifiersMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_OverrideDeathAction.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_OverrideDeathAction.uc
new file mode 100644
index 0000000..903aedd
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_OverrideDeathAction.uc
@@ -0,0 +1,47 @@
+class X2AbilityEffectsEditor_OverrideDeathAction extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_OverrideDeathAction');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_OverrideDeathAction DeathActionEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	DeathActionEffect = X2Effect_OverrideDeathAction(Effect);
+
+	if (DeathActionEffect == none)
+	{
+		return;
+	}
+
+	if (EffectEdit.SetDeathActionClass)
+	{
+		class'X2AbilityEditor_Logger'.static.LogInfo(
+			AbilityName,
+			Slot $ ".DeathActionClass",
+			PathName(DeathActionEffect.DeathActionClass),
+			EffectEdit.DeathActionClass
+		);
+
+		DeathActionEffect.DeathActionClass = class<X2Action>(DynamicLoadObject(EffectEdit.DeathActionClass, class'Class'));
+
+		if (DeathActionEffect.DeathActionClass == none && EffectEdit.DeathActionClass != "")
+		{
+			`log(
+				"AbilityEdit:" @ string(AbilityName) @ Slot $ ".DeathActionClass" @
+				"could not load class" @ EffectEdit.DeathActionClass,
+				class'X2DLCInfo_AbilityEditor'.default.EnableDebug,
+				'AbilityEditor'
+			);
+		}
+	}
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ParthenogenicPoison.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ParthenogenicPoison.uc
index a784199..5da3eec 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ParthenogenicPoison.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ParthenogenicPoison.uc
@@ -23,30 +23,6 @@ static function ApplyDerivedEdit(
 		return;
 	}
 
-	if (EffectEdit.SetParthenogenicPoisonType)
-	{
-		class'X2AbilityEditor_Logger'.static.LogInfo(
-			AbilityName,
-			Slot $ ".ParthenogenicPoisonType",
-			string(ParthenogenicPoisonFX.ParthenogenicPoisonType),
-			string(EffectEdit.ParthenogenicPoisonType)
-		);
-
-		ParthenogenicPoisonFX.ParthenogenicPoisonType = EffectEdit.ParthenogenicPoisonType;
-	}
-
-	if (EffectEdit.SetParthenogenicPoisonCocoonSpawnedName)
-	{
-		class'X2AbilityEditor_Logger'.static.LogInfo(
-			AbilityName,
-			Slot $ ".ParthenogenicPoisonCocoonSpawnedName",
-			string(ParthenogenicPoisonFX.ParthenogenicPoisonCocoonSpawnedName),
-			string(EffectEdit.ParthenogenicPoisonCocoonSpawnedName)
-		);
-
-		ParthenogenicPoisonFX.ParthenogenicPoisonCocoonSpawnedName = EffectEdit.ParthenogenicPoisonCocoonSpawnedName;
-	}
-
 	if (EffectEdit.SetAltUnitToSpawnName)
 	{
 		class'X2AbilityEditor_Logger'.static.LogInfo(
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Reaper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Reaper.uc
deleted file mode 100644
index b26f772..0000000
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Reaper.uc
+++ /dev/null
@@ -1,49 +0,0 @@
-class X2AbilityEffectsEditor_Reaper extends X2AbilityEffectsEditor_Persistent;
-
-static function bool CanEdit(X2Effect Effect)
-{
-	return Effect.IsA('X2Effect_Reaper');
-}
-
-static function ApplyDerivedEdit(
-	name AbilityName,
-	string Slot,
-	X2Effect Effect,
-	EffectEdit EffectEdit
-)
-{
-	local X2Effect_Reaper ReaperFX;
-
-	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
-
-	ReaperFX = X2Effect_Reaper(Effect);
-
-	if (ReaperFX == none)
-	{
-		return;
-	}
-
-	if (EffectEdit.SetReaperActivatedName)
-	{
-		class'X2AbilityEditor_Logger'.static.LogInfo(
-			AbilityName,
-			Slot $ ".ReaperActivatedName",
-			string(ReaperFX.ReaperActivatedName),
-			string(EffectEdit.ReaperActivatedName)
-		);
-
-		ReaperFX.ReaperActivatedName = EffectEdit.ReaperActivatedName;
-	}
-
-	if (EffectEdit.SetReaperKillName)
-	{
-		class'X2AbilityEditor_Logger'.static.LogInfo(
-			AbilityName,
-			Slot $ ".ReaperKillName",
-			string(ReaperFX.ReaperKillName),
-			string(EffectEdit.ReaperKillName)
-		);
-
-		ReaperFX.ReaperKillName = EffectEdit.ReaperKillName;
-	}
-}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ScanningProtocol.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ScanningProtocol.uc
deleted file mode 100644
index 9031932..0000000
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_ScanningProtocol.uc
+++ /dev/null
@@ -1,37 +0,0 @@
-class X2AbilityEffectsEditor_ScanningProtocol extends X2AbilityEffectsEditor_Persistent;
-
-static function bool CanEdit(X2Effect Effect)
-{
-	return Effect.IsA('X2Effect_ScanningProtocol');
-}
-
-static function ApplyDerivedEdit(
-	name AbilityName,
-	string Slot,
-	X2Effect Effect,
-	EffectEdit EffectEdit
-)
-{
-	local X2Effect_ScanningProtocol ScanningProtocolFX;
-
-	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
-
-	ScanningProtocolFX = X2Effect_ScanningProtocol(Effect);
-
-	if (ScanningProtocolFX == none)
-	{
-		return;
-	}
-
-	if (EffectEdit.SetLookAtDuration)
-	{
-		class'X2AbilityEditor_Logger'.static.LogInfo(
-			AbilityName,
-			Slot $ ".LookAtDuration",
-			string(ScanningProtocolFX.LookAtDuration),
-			string(EffectEdit.LookAtDuration)
-		);
-
-		ScanningProtocolFX.LookAtDuration = EffectEdit.LookAtDuration;
-	}
-}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Solace.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Solace.uc
new file mode 100644
index 0000000..6f45da9
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_Solace.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_Solace extends X2AbilityEffectsEditor_Persistent;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_Solace');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_Solace SolaceEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	SolaceEffect = X2Effect_Solace(Effect);
+
+	if (SolaceEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyNameArrayEdit(
+		AbilityName,
+		Slot $ ".DamageTypeImmunities",
+		SolaceEffect.DamageTypeImmunities,
+		EffectEdit.DamageTypeImmunities,
+		EffectEdit.DamageTypeImmunitiesMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_TemplarFocus.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_TemplarFocus.uc
new file mode 100644
index 0000000..8680d6b
--- /dev/null
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityEffectsEditor_TemplarFocus.uc
@@ -0,0 +1,33 @@
+class X2AbilityEffectsEditor_TemplarFocus extends X2AbilityEffectsEditor_ModifyStats;
+
+static function bool CanEdit(X2Effect Effect)
+{
+	return Effect.IsA('X2Effect_TemplarFocus');
+}
+
+static function ApplyDerivedEdit(
+	name AbilityName,
+	string Slot,
+	X2Effect Effect,
+	EffectEdit EffectEdit
+)
+{
+	local X2Effect_TemplarFocus FocusEffect;
+
+	super.ApplyDerivedEdit(AbilityName, Slot, Effect, EffectEdit);
+
+	FocusEffect = X2Effect_TemplarFocus(Effect);
+
+	if (FocusEffect == none)
+	{
+		return;
+	}
+
+	class'X2AbilityEditor_Helper'.static.ApplyFocusLevelModifiersArrayEdit(
+		AbilityName,
+		Slot $ ".arrFocusModifiers",
+		FocusEffect.arrFocusModifiers,
+		EffectEdit.FocusLevels,
+		EffectEdit.FocusLevelsMode
+	);
+}
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityMultiTargetStyleEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityMultiTargetStyleEditor_Helper.uc
index 30db3ee..42087ac 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityMultiTargetStyleEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityMultiTargetStyleEditor_Helper.uc
@@ -102,7 +102,8 @@ static function DispatchMultiTargetStyleEdit(
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.MultiTargetStyleEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.MultiTargetStyleEditors[i].static.CanEdit(MultiTargetStyle))
+		if (class'X2DLCInfo_AbilityEditor'.default.MultiTargetStyleEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.MultiTargetStyleEditors[i].static.CanEdit(MultiTargetStyle))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.MultiTargetStyleEditors[i].static.ApplyEdit(AbilityName, Slot, MultiTargetStyle, MultiTargetStyleEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTargetStyleEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTargetStyleEditor_Helper.uc
index 1e01998..eadd9cf 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTargetStyleEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTargetStyleEditor_Helper.uc
@@ -101,7 +101,8 @@ static function DispatchTargetStyleEdit(
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.TargetStyleEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.TargetStyleEditors[i].static.CanEdit(TargetStyle))
+		if (class'X2DLCInfo_AbilityEditor'.default.TargetStyleEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.TargetStyleEditors[i].static.CanEdit(TargetStyle))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.TargetStyleEditors[i].static.ApplyEdit(AbilityName, Slot, TargetStyle, TargetStyleEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityToHitCalcEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityToHitCalcEditor_Helper.uc
index 00f3acf..6757800 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityToHitCalcEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityToHitCalcEditor_Helper.uc
@@ -111,7 +111,8 @@ static function DispatchToHitCalcEdit(
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.ToHitCalcEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.ToHitCalcEditors[i].static.CanEdit(ToHitCalc))
+		if (class'X2DLCInfo_AbilityEditor'.default.ToHitCalcEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.ToHitCalcEditors[i].static.CanEdit(ToHitCalc))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.ToHitCalcEditors[i].static.ApplyEdit(AbilityName, Slot, ToHitCalc, ToHitCalcEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTriggerEditor_Helper.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTriggerEditor_Helper.uc
index 21f5fdc..fcc3b2d 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTriggerEditor_Helper.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2AbilityTriggerEditor_Helper.uc
@@ -129,7 +129,8 @@ static function DispatchTriggerEdit(
 
 	for (i = 0; i < class'X2DLCInfo_AbilityEditor'.default.TriggerEditors.Length; ++i)
 	{
-		if (class'X2DLCInfo_AbilityEditor'.default.TriggerEditors[i].static.CanEdit(Trigger))
+		if (class'X2DLCInfo_AbilityEditor'.default.TriggerEditors[i] != none &&
+			class'X2DLCInfo_AbilityEditor'.default.TriggerEditors[i].static.CanEdit(Trigger))
 		{
 			class'X2DLCInfo_AbilityEditor'.default.TriggerEditors[i].static.ApplyEdit(AbilityName, Slot, Trigger, TriggerEdit);
 			return;
diff --git a/AbilityEditor/Src/AbilityEditor/Classes/X2DLCInfo_AbilityEditor.uc b/AbilityEditor/Src/AbilityEditor/Classes/X2DLCInfo_AbilityEditor.uc
index 4935380..99f01a9 100644
--- a/AbilityEditor/Src/AbilityEditor/Classes/X2DLCInfo_AbilityEditor.uc
+++ b/AbilityEditor/Src/AbilityEditor/Classes/X2DLCInfo_AbilityEditor.uc
@@ -176,198 +176,214 @@ static function ApplyAbilityEdit(X2AbilityTemplate Template, AbilityEdit Ability
 
 defaultproperties
 {
-	ChargesEditors(0) = class'X2AbilityChargesEditor_CocoonSpawnChryssalid'
-	ChargesEditors(1) = class'X2AbilityChargesEditor_GremlinHeal'
-	ChargesEditors(2) = class'X2AbilityChargesEditor_RevivalProtocol'
-	ChargesEditors(3) = class'X2AbilityChargesEditor_ScanningProtocol'
-	ChargesEditors(4) = class'X2AbilityChargesEditor_StasisLance'
-	ChargesEditors(5) = class'X2AbilityChargesEditor_Base'
-
-	CooldownEditors(0) = class'X2AbilityCooldownEditor_AidProtocol'
-	CooldownEditors(1) = class'X2AbilityCooldownEditor_PerPlayerType'
-	CooldownEditors(2) = class'X2AbilityCooldownEditor_LocalAndGlobal'
-	CooldownEditors(3) = class'X2AbilityCooldownEditor_Global'
-	CooldownEditors(4) = class'X2AbilityCooldownEditor_Rend'
-	CooldownEditors(5) = class'X2AbilityCooldownEditor_Base'
-
-	CostEditors(0) = class'X2AbilityCostEditor_Ammo'
-	CostEditors(1) = class'X2AbilityCostEditor_Charges'
-	CostEditors(2) = class'X2AbilityCostEditor_ConsumeItem'
-	CostEditors(3) = class'X2AbilityCostEditor_Focus'
-	CostEditors(4) = class'X2AbilityCostEditor_ReserveActionPoints'
-	CostEditors(5) = class'X2AbilityCostEditor_HeavyWeaponActionPoints'
-	CostEditors(6) = class'X2AbilityCostEditor_QuickdrawActionPoints'
-	CostEditors(7) = class'X2AbilityCostEditor_ActionPoints'
-	CostEditors(8) = class'X2AbilityCostEditor_Base'
-
-	ConditionEditors(0) = class'X2AbilityConditionEditor_UnitEffectsApplying'
-	ConditionEditors(1) = class'X2AbilityConditionEditor_UnitEffectsOnSource'
-	ConditionEditors(2) = class'X2AbilityConditionEditor_UnitEffectsWithAbilitySource'
-	ConditionEditors(3) = class'X2AbilityConditionEditor_UnitEffectsWithAbilityTarget'
-	ConditionEditors(4) = class'X2AbilityConditionEditor_AbilityProperty'
-	ConditionEditors(5) = class'X2AbilityConditionEditor_AbilitySourceWeapon'
-	ConditionEditors(6) = class'X2AbilityConditionEditor_BattleState'
-	ConditionEditors(7) = class'X2AbilityConditionEditor_BerserkerDevastatingPunch'
-	ConditionEditors(8) = class'X2AbilityConditionEditor_Bondmate'
-	ConditionEditors(9) = class'X2AbilityConditionEditor_DarkEvent'
-	ConditionEditors(10) = class'X2AbilityConditionEditor_EverVigilant'
-	ConditionEditors(11) = class'X2AbilityConditionEditor_FuseTarget'
-	ConditionEditors(12) = class'X2AbilityConditionEditor_GameplayTag'
-	ConditionEditors(13) = class'X2AbilityConditionEditor_HackingTarget'
-	ConditionEditors(14) = class'X2AbilityConditionEditor_Interactive'
-	ConditionEditors(15) = class'X2AbilityConditionEditor_Lootable'
-	ConditionEditors(16) = class'X2AbilityConditionEditor_MapProperty'
-	ConditionEditors(17) = class'X2AbilityConditionEditor_OnGroundTile'
-	ConditionEditors(18) = class'X2AbilityConditionEditor_PanicOnPod'
-	ConditionEditors(19) = class'X2AbilityConditionEditor_PlayerTurns'
-	ConditionEditors(20) = class'X2AbilityConditionEditor_StasisLanceTarget'
-	ConditionEditors(21) = class'X2AbilityConditionEditor_StasisTarget'
-	ConditionEditors(22) = class'X2AbilityConditionEditor_Stealth'
-	ConditionEditors(23) = class'X2AbilityConditionEditor_UnblockedNeighborTile'
-	ConditionEditors(24) = class'X2AbilityConditionEditor_UnitActionPoints'
-	ConditionEditors(25) = class'X2AbilityConditionEditor_UnitAlertStatus'
-	ConditionEditors(26) = class'X2AbilityConditionEditor_UnitEffects'
-	ConditionEditors(27) = class'X2AbilityConditionEditor_UnitImmunities'
-	ConditionEditors(28) = class'X2AbilityConditionEditor_UnitInEvacZone'
-	ConditionEditors(29) = class'X2AbilityConditionEditor_UnitInteractions'
-	ConditionEditors(30) = class'X2AbilityConditionEditor_UnitInventory'
-	ConditionEditors(31) = class'X2AbilityConditionEditor_UnitProperty'
-	ConditionEditors(32) = class'X2AbilityConditionEditor_UnitStatCheck'
-	ConditionEditors(33) = class'X2AbilityConditionEditor_UnitType'
-	ConditionEditors(34) = class'X2AbilityConditionEditor_UnitValue'
-	ConditionEditors(35) = class'X2AbilityConditionEditor_Visibility'
-	ConditionEditors(36) = class'X2AbilityConditionEditor_Base'
-
-	EffectsEditors(0) = class'X2AbilityEffectsEditor_Obsessed'
-	EffectsEditors(1) = class'X2AbilityEffectsEditor_Shattered'
-	EffectsEditors(2) = class'X2AbilityEffectsEditor_VanishingWind'
-	EffectsEditors(3) = class'X2AbilityEffectsEditor_KineticPlating'
-	EffectsEditors(4) = class'X2AbilityEffectsEditor_Vanish'
-	EffectsEditors(5) = class'X2AbilityEffectsEditor_BlastPadding'
-	EffectsEditors(6) = class'X2AbilityEffectsEditor_KillUnit'
-	EffectsEditors(7) = class'X2AbilityEffectsEditor_ParthenogenicPoison'
-	EffectsEditors(8) = class'X2AbilityEffectsEditor_PersistentStatChange'
-	EffectsEditors(9) = class'X2AbilityEffectsEditor_PersistentStatChangeRestoreDefault'
-	EffectsEditors(10) = class'X2AbilityEffectsEditor_SpawnPsiZombie'
-	EffectsEditors(11) = class'X2AbilityEffectsEditor_SpawnShadowbindUnit'
-	EffectsEditors(12) = class'X2AbilityEffectsEditor_ThreatAssessment'
-	EffectsEditors(13) = class'X2AbilityEffectsEditor_WallBreaking'
-	EffectsEditors(14) = class'X2AbilityEffectsEditor_Achilles'
-	EffectsEditors(15) = class'X2AbilityEffectsEditor_AdverseSoldierClasses'
-	EffectsEditors(16) = class'X2AbilityEffectsEditor_Amplify'
-	EffectsEditors(17) = class'X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld'
-	EffectsEditors(18) = class'X2AbilityEffectsEditor_ApplyFireToWorld'
-	EffectsEditors(19) = class'X2AbilityEffectsEditor_APRounds'
-	EffectsEditors(20) = class'X2AbilityEffectsEditor_Aura'
-	EffectsEditors(21) = class'X2AbilityEffectsEditor_Bewildered'
-	EffectsEditors(22) = class'X2AbilityEffectsEditor_BloodTrail'
-	EffectsEditors(23) = class'X2AbilityEffectsEditor_BonusArmor'
-	EffectsEditors(24) = class'X2AbilityEffectsEditor_BonusWeaponDamage'
-	EffectsEditors(25) = class'X2AbilityEffectsEditor_ConditionalDamageModifier'
-	EffectsEditors(26) = class'X2AbilityEffectsEditor_CoveringFire'
-	EffectsEditors(27) = class'X2AbilityEffectsEditor_DamageImmunity'
-	EffectsEditors(28) = class'X2AbilityEffectsEditor_DelayedAbilityActivation'
-	EffectsEditors(29) = class'X2AbilityEffectsEditor_FaceMultiRoundTarget'
-	EffectsEditors(30) = class'X2AbilityEffectsEditor_GenerateCover'
-	EffectsEditors(31) = class'X2AbilityEffectsEditor_Groundling'
-	EffectsEditors(32) = class'X2AbilityEffectsEditor_Guardian'
-	EffectsEditors(33) = class'X2AbilityEffectsEditor_HoloTarget'
-	EffectsEditors(34) = class'X2AbilityEffectsEditor_HolyWarriorDeath'
-	EffectsEditors(35) = class'X2AbilityEffectsEditor_HomingMine'
-	EffectsEditors(36) = class'X2AbilityEffectsEditor_HuntersInstinctDamage'
-	EffectsEditors(37) = class'X2AbilityEffectsEditor_ImmediateAbilityActivation'
-	EffectsEditors(38) = class'X2AbilityEffectsEditor_Impatient'
-	EffectsEditors(39) = class'X2AbilityEffectsEditor_Implacable'
-	EffectsEditors(40) = class'X2AbilityEffectsEditor_LaserSight'
-	EffectsEditors(41) = class'X2AbilityEffectsEditor_MeleeDamageAdjust'
-	EffectsEditors(42) = class'X2AbilityEffectsEditor_MindControl'
-	EffectsEditors(43) = class'X2AbilityEffectsEditor_ModifyReactionFire'
-	EffectsEditors(44) = class'X2AbilityEffectsEditor_ModifyStats'
-	EffectsEditors(45) = class'X2AbilityEffectsEditor_Nearsighted'
-	EffectsEditors(46) = class'X2AbilityEffectsEditor_Needle'
-	EffectsEditors(47) = class'X2AbilityEffectsEditor_Oblivious'
-	EffectsEditors(48) = class'X2AbilityEffectsEditor_OverrideDeathAnimOnLoad'
-	EffectsEditors(49) = class'X2AbilityEffectsEditor_PaleHorse'
-	EffectsEditors(50) = class'X2AbilityEffectsEditor_PersistentSquadViewer'
-	EffectsEditors(51) = class'X2AbilityEffectsEditor_PersistentTraversalChange'
-	EffectsEditors(52) = class'X2AbilityEffectsEditor_PersistentVoidConduit'
-	EffectsEditors(53) = class'X2AbilityEffectsEditor_Possessed'
-	EffectsEditors(54) = class'X2AbilityEffectsEditor_Reaper'
-	EffectsEditors(55) = class'X2AbilityEffectsEditor_Regeneration'
-	EffectsEditors(56) = class'X2AbilityEffectsEditor_RemoveEffectsByDamageType'
-	EffectsEditors(57) = class'X2AbilityEffectsEditor_ReserveOverwatchPoints'
-	EffectsEditors(58) = class'X2AbilityEffectsEditor_RunBehaviorTree'
-	EffectsEditors(59) = class'X2AbilityEffectsEditor_ScanningProtocol'
-	EffectsEditors(60) = class'X2AbilityEffectsEditor_SmokeGrenade'
-	EffectsEditors(61) = class'X2AbilityEffectsEditor_SpawnDestructible'
-	EffectsEditors(62) = class'X2AbilityEffectsEditor_SpawnUnit'
-	EffectsEditors(63) = class'X2AbilityEffectsEditor_Stasis'
-	EffectsEditors(64) = class'X2AbilityEffectsEditor_Stunned'
-	EffectsEditors(65) = class'X2AbilityEffectsEditor_SuperConcealModifier'
-	EffectsEditors(66) = class'X2AbilityEffectsEditor_Sustain'
-	EffectsEditors(67) = class'X2AbilityEffectsEditor_Sustained'
-	EffectsEditors(68) = class'X2AbilityEffectsEditor_TalonRounds'
-	EffectsEditors(69) = class'X2AbilityEffectsEditor_TargetDamageDistanceBonus'
-	EffectsEditors(70) = class'X2AbilityEffectsEditor_TargetDamageTypeBonus'
-	EffectsEditors(71) = class'X2AbilityEffectsEditor_ToHitModifier'
-	EffectsEditors(72) = class'X2AbilityEffectsEditor_TrackingShotMarkTarget'
-	EffectsEditors(73) = class'X2AbilityEffectsEditor_TurnStartActionPoints'
-	EffectsEditors(74) = class'X2AbilityEffectsEditor_VolatileMix'
-	EffectsEditors(75) = class'X2AbilityEffectsEditor_ApplyDirectionalWorldDamage'
-	EffectsEditors(76) = class'X2AbilityEffectsEditor_ApplyMedikitHeal'
-	EffectsEditors(77) = class'X2AbilityEffectsEditor_ApplyWeaponDamage'
-	EffectsEditors(78) = class'X2AbilityEffectsEditor_Brutal'
-	EffectsEditors(79) = class'X2AbilityEffectsEditor_EnableGlobalAbility'
-	EffectsEditors(80) = class'X2AbilityEffectsEditor_GetOverHere'
-	EffectsEditors(81) = class'X2AbilityEffectsEditor_GrantActionPoints'
-	EffectsEditors(82) = class'X2AbilityEffectsEditor_IncreaseBondmateCohesion'
-	EffectsEditors(83) = class'X2AbilityEffectsEditor_Knockback'
-	EffectsEditors(84) = class'X2AbilityEffectsEditor_LifeSteal'
-	EffectsEditors(85) = class'X2AbilityEffectsEditor_MarkValidActivationTiles'
-	EffectsEditors(86) = class'X2AbilityEffectsEditor_ModifyInitiativeOrder'
-	EffectsEditors(87) = class'X2AbilityEffectsEditor_ModifyTemplarFocus'
-	EffectsEditors(88) = class'X2AbilityEffectsEditor_LethalWeaponDamage'
-	EffectsEditors(89) = class'X2AbilityEffectsEditor_Persistent'
-	EffectsEditors(90) = class'X2AbilityEffectsEditor_ReduceCooldowns'
-	EffectsEditors(91) = class'X2AbilityEffectsEditor_RemoteStart'
-	EffectsEditors(92) = class'X2AbilityEffectsEditor_RemoveEffects'
-	EffectsEditors(93) = class'X2AbilityEffectsEditor_ReserveActionPoints'
-	EffectsEditors(94) = class'X2AbilityEffectsEditor_SetUnitValue'
-	EffectsEditors(95) = class'X2AbilityEffectsEditor_SoulSteal'
-	EffectsEditors(96) = class'X2AbilityEffectsEditor_Spotted'
-	EffectsEditors(97) = class'X2AbilityEffectsEditor_SuspendMissionTimer'
-	EffectsEditors(98) = class'X2AbilityEffectsEditor_TriggerEvent'
-	EffectsEditors(99) = class'X2AbilityEffectsEditor_VoidConduit'
-	EffectsEditors(100) = class'X2AbilityEffectsEditor_World'
-	EffectsEditors(101) = class'X2AbilityEffectsEditor_Base'
-
-	ToHitCalcEditors(0) = class'X2AbilityToHitCalcEditor_StatCheck_UnitVsUnit'
-	ToHitCalcEditors(1) = class'X2AbilityToHitCalcEditor_PercentChancePlusFocus'
-	ToHitCalcEditors(2) = class'X2AbilityToHitCalcEditor_PercentChanceWithBuddyZone'
-	ToHitCalcEditors(3) = class'X2AbilityToHitCalcEditor_StandardAim'
-	ToHitCalcEditors(4) = class'X2AbilityToHitCalcEditor_PercentChance'
-	ToHitCalcEditors(5) = class'X2AbilityToHitCalcEditor_Hacking'
-	ToHitCalcEditors(6) = class'X2AbilityToHitCalcEditor_RollStat'
-	ToHitCalcEditors(7) = class'X2AbilityToHitCalcEditor_RollStatTiers'
-	ToHitCalcEditors(8) = class'X2AbilityToHitCalcEditor_StatCheck'
-	ToHitCalcEditors(9) = class'X2AbilityToHitCalcEditor_Base'
-
-	TargetStyleEditors(0) = class'X2AbilityTargetStyleEditor_MovingMelee'
-	TargetStyleEditors(1) = class'X2AbilityTargetStyleEditor_Single'
-	TargetStyleEditors(2) = class'X2AbilityTargetStyleEditor_Cursor'
-	TargetStyleEditors(3) = class'X2AbilityTargetStyleEditor_Base'
-
-	MultiTargetStyleEditors(0) = class'X2AbilityMultiTargetStyleEditor_Cone'
-	MultiTargetStyleEditors(1) = class'X2AbilityMultiTargetStyleEditor_Cylinder'
-	MultiTargetStyleEditors(2) = class'X2AbilityMultiTargetStyleEditor_AllUnits'
-	MultiTargetStyleEditors(3) = class'X2AbilityMultiTargetStyleEditor_ClaymoreRadius'
-	MultiTargetStyleEditors(4) = class'X2AbilityMultiTargetStyleEditor_Radius'
-	MultiTargetStyleEditors(5) = class'X2AbilityMultiTargetStyleEditor_Line'
-	MultiTargetStyleEditors(6) = class'X2AbilityMultiTargetStyleEditor_BurstFire'
-	MultiTargetStyleEditors(7) = class'X2AbilityMultiTargetStyleEditor_Base'
-
-	TriggerEditors(0) = class'X2AbilityTriggerEditor_UnitPostBeginPlay'
-	TriggerEditors(1) = class'X2AbilityTriggerEditor_EventListener'
-	TriggerEditors(2) = class'X2AbilityTriggerEditor_Event'
-	TriggerEditors(3) = class'X2AbilityTriggerEditor_Base'
+	ChargesEditors.Add(class'X2AbilityChargesEditor_CocoonSpawnChryssalid')
+	ChargesEditors.Add(class'X2AbilityChargesEditor_GremlinHeal')
+	ChargesEditors.Add(class'X2AbilityChargesEditor_RevivalProtocol')
+	ChargesEditors.Add(class'X2AbilityChargesEditor_ScanningProtocol')
+	ChargesEditors.Add(class'X2AbilityChargesEditor_StasisLance')
+	ChargesEditors.Add(class'X2AbilityChargesEditor_Base')
+
+	CooldownEditors.Add(class'X2AbilityCooldownEditor_AidProtocol')
+	CooldownEditors.Add(class'X2AbilityCooldownEditor_PerPlayerType')
+	CooldownEditors.Add(class'X2AbilityCooldownEditor_LocalAndGlobal')
+	CooldownEditors.Add(class'X2AbilityCooldownEditor_Global')
+	CooldownEditors.Add(class'X2AbilityCooldownEditor_Rend')
+	CooldownEditors.Add(class'X2AbilityCooldownEditor_Base')
+
+	CostEditors.Add(class'X2AbilityCostEditor_Ammo')
+	CostEditors.Add(class'X2AbilityCostEditor_Charges')
+	CostEditors.Add(class'X2AbilityCostEditor_ConsumeItem')
+	CostEditors.Add(class'X2AbilityCostEditor_Focus')
+	CostEditors.Add(class'X2AbilityCostEditor_ReserveActionPoints')
+	CostEditors.Add(class'X2AbilityCostEditor_HeavyWeaponActionPoints')
+	CostEditors.Add(class'X2AbilityCostEditor_QuickdrawActionPoints')
+	CostEditors.Add(class'X2AbilityCostEditor_ActionPoints')
+	CostEditors.Add(class'X2AbilityCostEditor_Base')
+
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitEffectsApplying')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitEffectsOnSource')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitEffectsWithAbilitySource')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitEffectsWithAbilityTarget')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_AbilityProperty')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_AbilitySourceWeapon')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_BattleState')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_BerserkerDevastatingPunch')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_Bondmate')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_DarkEvent')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_EverVigilant')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_FuseTarget')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_GameplayTag')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_GameTime')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_HackingTarget')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_Interactive')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_Lootable')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_MapProperty')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_OnGroundTile')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_PanicOnPod')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_PlayerTurns')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_StasisLanceTarget')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_StasisTarget')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_Stealth')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnblockedNeighborTile')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitActionPoints')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitAlertStatus')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitEffects')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitImmunities')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitInEvacZone')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitInteractions')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitInventory')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitProperty')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitStatCheck')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitType')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_UnitValue')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_Visibility')
+	ConditionEditors.Add(class'X2AbilityConditionEditor_Base')
+
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Obsessed')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Shattered')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_VanishingWind')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_KineticPlating')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Vanish')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_BlastPadding')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_KillUnit')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ParthenogenicPoison')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_PersistentStatChange')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_PersistentStatChangeRestoreDefault')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SpawnPsiZombie')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SpawnShadowbindUnit')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ThreatAssessment')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_WallBreaking')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Achilles')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_AdverseSoldierClasses')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Amplify')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyAcidToWorld')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyFireToWorld')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyPoisonToWorld')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplySmokeToWorld')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_APRounds')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Aura')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Bewildered')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_BloodTrail')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_BondmateAimAdjust')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_BondmateBleedout')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_CombatStims')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_BonusArmor')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_BonusWeaponDamage')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ChryssalidBurrowedAttack')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ConditionalDamageModifier')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_CoveringFire')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_DamageImmunity')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_DeadeyeDamage')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_DelayedAbilityActivation')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_FaceMultiRoundTarget')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Fortress')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_GenerateCover')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Groundling')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Guardian')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_HoloTarget')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_HolyWarriorDeath')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_HomingMine')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_HuntersInstinctDamage')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ImmediateAbilityActivation')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Impatient')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Implacable')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_LaserSight')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_MeleeDamageAdjust')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_MimicBeacon')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_MindControl')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ModifyReactionFire')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ModifyStatCheckSuccesses')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TemplarFocus')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ModifyStats')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Nearsighted')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Needle')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Oblivious')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_OverrideDeathAction')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_OverrideDeathAnimOnLoad')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_PaleHorse')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_PersistentSquadViewer')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_PersistentTraversalChange')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_PersistentVoidConduit')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Possessed')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Regeneration')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_RemoveEffectsByDamageType')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ReserveOverwatchPoints')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_RunBehaviorTree')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SmokeGrenade')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Solace')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SpawnDestructible')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SpawnUnit')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Stasis')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Stunned')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SuperConcealModifier')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Sustain')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Sustained')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TalonRounds')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TargetDamageDistanceBonus')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TargetDamageTypeBonus')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ToHitModifier')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TrackingShotMarkTarget')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TurnStartActionPoints')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_VolatileMix')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_AlertTheLost')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyDirectionalWorldDamage')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyMedikitHeal')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ApplyWeaponDamage')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Brutal')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_EnableGlobalAbility')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_GetOverHere')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_GrantActionPointsWithRecord')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_GrantActionPoints')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_IncreaseBondmateCohesion')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Knockback')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_LifeSteal')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_MarkValidActivationTiles')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ModifyInitiativeOrder')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ModifyTemplarFocus')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_LethalWeaponDamage')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Persistent')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ReduceCooldowns')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_RemoteStart')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_RemoveEffects')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_ReserveActionPoints')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SetUnitValue')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SoulSteal')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Spotted')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_SuspendMissionTimer')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_TriggerEvent')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_VoidConduit')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_World')
+	EffectsEditors.Add(class'X2AbilityEffectsEditor_Base')
+
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_StatCheck_UnitVsUnit')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_PercentChancePlusFocus')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_PercentChanceWithBuddyZone')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_StandardAim')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_PercentChance')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_Hacking')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_RollStat')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_RollStatTiers')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_StatCheck')
+	ToHitCalcEditors.Add(class'X2AbilityToHitCalcEditor_Base')
+
+	TargetStyleEditors.Add(class'X2AbilityTargetStyleEditor_MovingMelee')
+	TargetStyleEditors.Add(class'X2AbilityTargetStyleEditor_Single')
+	TargetStyleEditors.Add(class'X2AbilityTargetStyleEditor_Cursor')
+	TargetStyleEditors.Add(class'X2AbilityTargetStyleEditor_Base')
+
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_Cone')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_Cylinder')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_AllUnits')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_ClaymoreRadius')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_Radius')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_Line')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_BurstFire')
+	MultiTargetStyleEditors.Add(class'X2AbilityMultiTargetStyleEditor_Base')
+
+	TriggerEditors.Add(class'X2AbilityTriggerEditor_UnitPostBeginPlay')
+	TriggerEditors.Add(class'X2AbilityTriggerEditor_EventListener')
+	TriggerEditors.Add(class'X2AbilityTriggerEditor_Event')
+	TriggerEditors.Add(class'X2AbilityTriggerEditor_Base')
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ebeac96..d66ed8a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,10 +11,67 @@ This project follows [Keep a Changelog](https://keepachangelog.com/) and
 
 ### Added
 
+- **Damage-over-time effects can now be retuned.** A persistent effect is only the *state*;
+  what it does each turn lives in a child effect inside its `ApplyOnTick` list. Editing
+  `X2Effect_Burning` reached its duration but never its damage, which sits in a nested
+  `X2Effect_ApplyWeaponDamage`. Three new `EffectEdit` keys — `ApplyOnTickClass`,
+  `ApplyOnTickIndex` and `ApplyOnTickMode` - redirect an entry at that child, so the rest of
+  the entry edits it instead.
+
+  ```ini
+  ; Molotov burn ticks for 5 (+/-2) instead of its usual damage
+  +AbilityEdits=( \\
+      Ability=ThrowMolotov, \\
+      Effects=( \\
+          ( Class="X2Effect_Burning", Mode=eAEM_Merge, \\
+            ApplyOnTickClass="X2Effect_ApplyWeaponDamage", ApplyOnTickMode=eAEM_Merge, \\
+            WeaponDamageValue=(SetDamage=true, Damage=5, SetSpread=true, Spread=2) ) \\
+      ) \\
+  )
+  ```
+
+  This is not specific to burning. It reaches every vanilla effect that uses the pattern -
+  poisoned, bleeding, parthenogenic poison, Steady Hands, Void Conduit, the evac delay and
+  Alert Mechanics - and modded ones too.
+
 - **A documentation site** at [boundir.github.io/AbilityEditor](https://boundir.github.io/AbilityEditor/),
   built with mkdocs-material and published by GitHub Actions. Game classes haves their own page
   with a guessable URL (`/reference/effects/x2effect_achilles/`), so a link can point at one class instead of one page documentation.
 
+- **A config builder** at [boundir.github.io/AbilityEditor/app](https://boundir.github.io/AbilityEditor/app/).
+  Pick an ability, tick the fields, get the `+AbilityEdits` entry - with the mode-default and missing-`Set` mistakes flagged before the game silently ignores them. Paste an existing entry in to check it.
+
+- **Fifteen more effect editors and one condition editor.** `X2Effect_ApplyAcidToWorld`,
+  `ApplyPoisonToWorld`, `ApplySmokeToWorld`, `ApplySmokeGrenadeToWorld` (particle systems);
+  `Fortress`, `DeadeyeDamage`, `AlertTheLost`; `Solace`, `CombatStims`,
+  `ChryssalidBurrowedAttack`, `BondmateAimAdjust`, `BondmateBleedout`, `MimicBeacon`;
+  `ModifyStatCheckSuccesses`, `TemplarFocus`, `GrantActionPointsWithRecord`,
+  `OverrideDeathAction`; and `X2Condition_GameTime`. Struct-array fields such as
+  `TemplarFocus.FocusLevels` take the game's own structs:
+
+  ```ini
+  ; Templars start at +1 Mobility on focus level 0
+  +AbilityEdits=( \\
+      Ability=TemplarFocus, \\
+      Effects=( \\
+          ( Class="X2Effect_TemplarFocus", Mode=eAEM_Merge, FocusLevelsMode=eNAEM_Merge, \\
+            FocusLevels=( (StatChanges=((StatType=eStat_Mobility, StatAmount=1.0)), ArmorMitigation=0, WeaponDamage=0) ) ) \\
+      ) \\
+  )
+  ```
+
+- **Every config key now has a description** on the reference pages and in `docs/schema.json`.
+
+### Changed
+
+- Fields renaming:
+  `AcidParticleSystem1Tile` … `AcidParticleSystem4TilesReverseS`, `PoisonParticleSystem`, `SmokeParticleSystem`, and `OverrideParticleSystem` in place of `OverrideParticleSystemFill_Name`.
+
+### Removed
+
+- Five effect fields that never did anything, because the game reads them from the class default rather than the ability: `ReaperActivatedName`, `ReaperKillName` (`X2Effect_Reaper`), `LookAtDuration` (`X2Effect_ScanningProtocol`), `ParthenogenicPoisonType` and `ParthenogenicPoisonCocoonSpawnedName`.
+  The Reaper and ScanningProtocol editors went with them; both classes still take the shared persistent-effect fields.
+
 ### Fixed
 
 - **Replace-only array fields no longer advertise a mode field that doesn't exist.** The reference
@@ -34,13 +91,9 @@ This project follows [Keep a Changelog](https://keepachangelog.com/) and
 
 ### Documentation
 
-- Documented that building the mod requires Community Highlander-patched SDK sources
-  ([Issue #68](https://github.com/X2CommunityCore/X2WOTCCommunityHighlander/issues/68) removes
-  `protectedwrite` from the three `X2AbilityTemplate` effect arrays this mod writes). This is a
-  build-time requirement only - the compiled mod runs against vanilla `XComGame`.
-- Corrected the field-documentation convention: a `//` comment must sit directly above the **value**
-  var, not above the `Set`/value pair. A comment above the pair attaches to the guard and is
-  dropped, which is why 219 existing comments act as section headers rather than field docs.
+- Corrected the field-documentation convention: a `//` comment must sit directly above the **value** var, not above the `Set`/value pair.
+  A comment above the pair attaches to the guard and is dropped, which is why 219 existing comments act as section headers rather than field docs.
+- A [Why isn't this editable?](docs/contributing/coverage-triage.md) page records the game fields that do not have an editor and the reason for each - mostly fields the game reads from the class default, which are tunable globally in the game's own ini.
 
 ## [2.0.0] - 2026-07-10
 
diff --git a/README.md b/README.md
index 99ab5cd..2906f54 100644
--- a/README.md
+++ b/README.md
@@ -45,8 +45,8 @@ An `+AbilityEdits` entry can change:
 - **Costs** (`Costs`) &mdash; `X2AbilityCost_Ammo`, `X2AbilityCost_Charges`, `X2AbilityCost_ConsumeItem`, `X2AbilityCost_Focus`, `X2AbilityCost_ReserveActionPoints`, `X2AbilityCost_HeavyWeaponActionPoints`, `X2AbilityCost_QuickdrawActionPoints`, `X2AbilityCost_ActionPoints` &mdash; plus shared fields on any other subclass
 - **Cooldown** (`Cooldown`) &mdash; `X2AbilityCooldown_AidProtocol`, `X2AbilityCooldown_PerPlayerType`, `X2AbilityCooldown_LocalAndGlobal`, `X2AbilityCooldown_Global`, `X2AbilityCooldown_Rend` &mdash; plus shared fields on any other subclass
 - **Charges** (`Charges`) &mdash; `X2AbilityCharges_CocoonSpawnChryssalid`, `X2AbilityCharges_GremlinHeal`, `X2AbilityCharges_RevivalProtocol`, `X2AbilityCharges_ScanningProtocol`, `X2AbilityCharges_StasisLance` &mdash; plus shared fields on any other subclass
-- **Effects** (`Effects`) &mdash; `X2Effect_Obsessed`, `X2Effect_Shattered`, `X2Effect_VanishingWind`, `X2Effect_KineticPlating`, `X2Effect_Vanish`, `X2Effect_BlastPadding`, `X2Effect_KillUnit`, `X2Effect_ParthenogenicPoison`, `X2Effect_PersistentStatChange`, `X2Effect_PersistentStatChangeRestoreDefault`, `X2Effect_SpawnPsiZombie`, `X2Effect_SpawnShadowbindUnit`, `X2Effect_ThreatAssessment`, `X2Effect_WallBreaking`, `X2Effect_Achilles`, `X2Effect_AdverseSoldierClasses`, `X2Effect_Amplify`, `X2Effect_ApplyBlazingPinionsTargetToWorld`, `X2Effect_ApplyFireToWorld`, `X2Effect_APRounds`, `X2Effect_Aura`, `X2Effect_Bewildered`, `X2Effect_BloodTrail`, `X2Effect_BonusArmor`, `X2Effect_BonusWeaponDamage`, `X2Effect_ConditionalDamageModifier`, `X2Effect_CoveringFire`, `X2Effect_DamageImmunity`, `X2Effect_DelayedAbilityActivation`, `X2Effect_FaceMultiRoundTarget`, `X2Effect_GenerateCover`, `X2Effect_Groundling`, `X2Effect_Guardian`, `X2Effect_HoloTarget`, `X2Effect_HolyWarriorDeath`, `X2Effect_HomingMine`, `X2Effect_HuntersInstinctDamage`, `X2Effect_ImmediateAbilityActivation`, `X2Effect_Impatient`, `X2Effect_Implacable`, `X2Effect_LaserSight`, `X2Effect_MeleeDamageAdjust`, `X2Effect_MindControl`, `X2Effect_ModifyReactionFire`, `X2Effect_ModifyStats`, `X2Effect_Nearsighted`, `X2Effect_Needle`, `X2Effect_Oblivious`, `X2Effect_OverrideDeathAnimOnLoad`, `X2Effect_PaleHorse`, `X2Effect_PersistentSquadViewer`, `X2Effect_PersistentTraversalChange`, `X2Effect_PersistentVoidConduit`, `X2Effect_Possessed`, `X2Effect_Reaper`, `X2Effect_Regeneration`, `X2Effect_RemoveEffectsByDamageType`, `X2Effect_ReserveOverwatchPoints`, `X2Effect_RunBehaviorTree`, `X2Effect_ScanningProtocol`, `X2Effect_SmokeGrenade`, `X2Effect_SpawnDestructible`, `X2Effect_SpawnUnit`, `X2Effect_Stasis`, `X2Effect_Stunned`, `X2Effect_SuperConcealModifier`, `X2Effect_Sustain`, `X2Effect_Sustained`, `X2Effect_TalonRounds`, `X2Effect_TargetDamageDistanceBonus`, `X2Effect_TargetDamageTypeBonus`, `X2Effect_ToHitModifier`, `X2Effect_TrackingShotMarkTarget`, `X2Effect_TurnStartActionPoints`, `X2Effect_VolatileMix`, `X2Effect_ApplyDirectionalWorldDamage`, `X2Effect_ApplyMedikitHeal`, `X2Effect_ApplyWeaponDamage`, `X2Effect_Brutal`, `X2Effect_EnableGlobalAbility`, `X2Effect_GetOverHere`, `X2Effect_GrantActionPoints`, `X2Effect_IncreaseBondmateCohesion`, `X2Effect_Knockback`, `X2Effect_LifeSteal`, `X2Effect_MarkValidActivationTiles`, `X2Effect_ModifyInitiativeOrder`, `X2Effect_ModifyTemplarFocus`, `X2Effect_LethalWeaponDamage`, `X2Effect_Persistent`, `X2Effect_ReduceCooldowns`, `X2Effect_RemoteStart`, `X2Effect_RemoveEffects`, `X2Effect_ReserveActionPoints`, `X2Effect_SetUnitValue`, `X2Effect_SoulSteal`, `X2Effect_Spotted`, `X2Effect_SuspendMissionTimer`, `X2Effect_TriggerEvent`, `X2Effect_VoidConduit`, `X2Effect_World` &mdash; plus shared fields on any other subclass
-- **Conditions** &mdash; `X2Condition_UnitEffectsApplying`, `X2Condition_UnitEffectsOnSource`, `X2Condition_UnitEffectsWithAbilitySource`, `X2Condition_UnitEffectsWithAbilityTarget`, `X2Condition_AbilityProperty`, `X2Condition_AbilitySourceWeapon`, `X2Condition_BattleState`, `X2Condition_BerserkerDevastatingPunch`, `X2Condition_Bondmate`, `X2Condition_DarkEvent`, `X2Condition_EverVigilant`, `X2Condition_FuseTarget`, `X2Condition_GameplayTag`, `X2Condition_HackingTarget`, `X2Condition_Interactive`, `X2Condition_Lootable`, `X2Condition_MapProperty`, `X2Condition_OnGroundTile`, `X2Condition_PanicOnPod`, `X2Condition_PlayerTurns`, `X2Condition_StasisLanceTarget`, `X2Condition_StasisTarget`, `X2Condition_Stealth`, `X2Condition_UnblockedNeighborTile`, `X2Condition_UnitActionPoints`, `X2Condition_UnitAlertStatus`, `X2Condition_UnitEffects`, `X2Condition_UnitImmunities`, `X2Condition_UnitInEvacZone`, `X2Condition_UnitInteractions`, `X2Condition_UnitInventory`, `X2Condition_UnitProperty`, `X2Condition_UnitStatCheck`, `X2Condition_UnitType`, `X2Condition_UnitValue`, `X2Condition_Visibility` &mdash; plus shared fields on any other subclass
+- **Effects** (`Effects`) &mdash; `X2Effect_Obsessed`, `X2Effect_Shattered`, `X2Effect_VanishingWind`, `X2Effect_KineticPlating`, `X2Effect_Vanish`, `X2Effect_BlastPadding`, `X2Effect_KillUnit`, `X2Effect_ParthenogenicPoison`, `X2Effect_PersistentStatChange`, `X2Effect_PersistentStatChangeRestoreDefault`, `X2Effect_SpawnPsiZombie`, `X2Effect_SpawnShadowbindUnit`, `X2Effect_ThreatAssessment`, `X2Effect_WallBreaking`, `X2Effect_Achilles`, `X2Effect_AdverseSoldierClasses`, `X2Effect_Amplify`, `X2Effect_ApplyAcidToWorld`, `X2Effect_ApplyBlazingPinionsTargetToWorld`, `X2Effect_ApplyFireToWorld`, `X2Effect_ApplyPoisonToWorld`, `X2Effect_ApplySmokeGrenadeToWorld`, `X2Effect_ApplySmokeToWorld`, `X2Effect_APRounds`, `X2Effect_Aura`, `X2Effect_Bewildered`, `X2Effect_BloodTrail`, `X2Effect_BondmateAimAdjust`, `X2Effect_BondmateBleedout`, `X2Effect_CombatStims`, `X2Effect_BonusArmor`, `X2Effect_BonusWeaponDamage`, `X2Effect_ChryssalidBurrowedAttack`, `X2Effect_ConditionalDamageModifier`, `X2Effect_CoveringFire`, `X2Effect_DamageImmunity`, `X2Effect_DeadeyeDamage`, `X2Effect_DelayedAbilityActivation`, `X2Effect_FaceMultiRoundTarget`, `X2Effect_Fortress`, `X2Effect_GenerateCover`, `X2Effect_Groundling`, `X2Effect_Guardian`, `X2Effect_HoloTarget`, `X2Effect_HolyWarriorDeath`, `X2Effect_HomingMine`, `X2Effect_HuntersInstinctDamage`, `X2Effect_ImmediateAbilityActivation`, `X2Effect_Impatient`, `X2Effect_Implacable`, `X2Effect_LaserSight`, `X2Effect_MeleeDamageAdjust`, `X2Effect_MimicBeacon`, `X2Effect_MindControl`, `X2Effect_ModifyReactionFire`, `X2Effect_ModifyStatCheckSuccesses`, `X2Effect_TemplarFocus`, `X2Effect_ModifyStats`, `X2Effect_Nearsighted`, `X2Effect_Needle`, `X2Effect_Oblivious`, `X2Effect_OverrideDeathAction`, `X2Effect_OverrideDeathAnimOnLoad`, `X2Effect_PaleHorse`, `X2Effect_PersistentSquadViewer`, `X2Effect_PersistentTraversalChange`, `X2Effect_PersistentVoidConduit`, `X2Effect_Possessed`, `X2Effect_Regeneration`, `X2Effect_RemoveEffectsByDamageType`, `X2Effect_ReserveOverwatchPoints`, `X2Effect_RunBehaviorTree`, `X2Effect_SmokeGrenade`, `X2Effect_Solace`, `X2Effect_SpawnDestructible`, `X2Effect_SpawnUnit`, `X2Effect_Stasis`, `X2Effect_Stunned`, `X2Effect_SuperConcealModifier`, `X2Effect_Sustain`, `X2Effect_Sustained`, `X2Effect_TalonRounds`, `X2Effect_TargetDamageDistanceBonus`, `X2Effect_TargetDamageTypeBonus`, `X2Effect_ToHitModifier`, `X2Effect_TrackingShotMarkTarget`, `X2Effect_TurnStartActionPoints`, `X2Effect_VolatileMix`, `X2Effect_AlertTheLost`, `X2Effect_ApplyDirectionalWorldDamage`, `X2Effect_ApplyMedikitHeal`, `X2Effect_ApplyWeaponDamage`, `X2Effect_Brutal`, `X2Effect_EnableGlobalAbility`, `X2Effect_GetOverHere`, `X2Effect_GrantActionPointsWithRecord`, `X2Effect_GrantActionPoints`, `X2Effect_IncreaseBondmateCohesion`, `X2Effect_Knockback`, `X2Effect_LifeSteal`, `X2Effect_MarkValidActivationTiles`, `X2Effect_ModifyInitiativeOrder`, `X2Effect_ModifyTemplarFocus`, `X2Effect_LethalWeaponDamage`, `X2Effect_Persistent`, `X2Effect_ReduceCooldowns`, `X2Effect_RemoteStart`, `X2Effect_RemoveEffects`, `X2Effect_ReserveActionPoints`, `X2Effect_SetUnitValue`, `X2Effect_SoulSteal`, `X2Effect_Spotted`, `X2Effect_SuspendMissionTimer`, `X2Effect_TriggerEvent`, `X2Effect_VoidConduit`, `X2Effect_World` &mdash; plus shared fields on any other subclass
+- **Conditions** &mdash; `X2Condition_UnitEffectsApplying`, `X2Condition_UnitEffectsOnSource`, `X2Condition_UnitEffectsWithAbilitySource`, `X2Condition_UnitEffectsWithAbilityTarget`, `X2Condition_AbilityProperty`, `X2Condition_AbilitySourceWeapon`, `X2Condition_BattleState`, `X2Condition_BerserkerDevastatingPunch`, `X2Condition_Bondmate`, `X2Condition_DarkEvent`, `X2Condition_EverVigilant`, `X2Condition_FuseTarget`, `X2Condition_GameplayTag`, `X2Condition_GameTime`, `X2Condition_HackingTarget`, `X2Condition_Interactive`, `X2Condition_Lootable`, `X2Condition_MapProperty`, `X2Condition_OnGroundTile`, `X2Condition_PanicOnPod`, `X2Condition_PlayerTurns`, `X2Condition_StasisLanceTarget`, `X2Condition_StasisTarget`, `X2Condition_Stealth`, `X2Condition_UnblockedNeighborTile`, `X2Condition_UnitActionPoints`, `X2Condition_UnitAlertStatus`, `X2Condition_UnitEffects`, `X2Condition_UnitImmunities`, `X2Condition_UnitInEvacZone`, `X2Condition_UnitInteractions`, `X2Condition_UnitInventory`, `X2Condition_UnitProperty`, `X2Condition_UnitStatCheck`, `X2Condition_UnitType`, `X2Condition_UnitValue`, `X2Condition_Visibility` &mdash; plus shared fields on any other subclass
 - **ToHitCalc** (`ToHitCalc`) &mdash; `X2AbilityToHitCalc_StatCheck_UnitVsUnit`, `X2AbilityToHitCalc_PercentChancePlusFocus`, `X2AbilityToHitCalc_PercentChanceWithBuddyZone`, `X2AbilityToHitCalc_StandardAim`, `X2AbilityToHitCalc_PercentChance`, `X2AbilityToHitCalc_Hacking`, `X2AbilityToHitCalc_RollStat`, `X2AbilityToHitCalc_RollStatTiers`, `X2AbilityToHitCalc_StatCheck` &mdash; plus shared fields on any other subclass
 - **TargetStyle** (`TargetStyle`) &mdash; `X2AbilityTarget_MovingMelee`, `X2AbilityTarget_Single`, `X2AbilityTarget_Cursor` &mdash; plus shared fields on any other subclass
 - **MultiTargetStyle** (`MultiTargetStyle`) &mdash; `X2AbilityMultiTarget_Cone`, `X2AbilityMultiTarget_Cylinder`, `X2AbilityMultiTarget_AllUnits`, `X2AbilityMultiTarget_ClaymoreRadius`, `X2AbilityMultiTarget_Radius`, `X2AbilityMultiTarget_Line`, `X2AbilityMultiTarget_BurstFire` &mdash; plus shared fields on any other subclass
diff --git a/SdkOverlay/XComGame/Classes/X2Effect_BondmateAimAdjust.uc b/SdkOverlay/XComGame/Classes/X2Effect_BondmateAimAdjust.uc
new file mode 100644
index 0000000..1a6e29e
--- /dev/null
+++ b/SdkOverlay/XComGame/Classes/X2Effect_BondmateAimAdjust.uc
@@ -0,0 +1,208 @@
+//---------------------------------------------------------------------------------------
+//  FILE:    X2Effect_BondmateAimAdjust.uc
+//  AUTHOR:  David Burchanowski  --  10/28/2016
+//  PURPOSE: Effect to increase aim against enemies that are targeting your bondmate
+//           
+//---------------------------------------------------------------------------------------
+//  Copyright (c) 2016 Firaxis Games, Inc. All rights reserved.
+//---------------------------------------------------------------------------------------
+
+class X2Effect_BondmateAimAdjust extends X2Effect_Persistent
+	config(GameCore);
+
+var config int ThreatenedBondmateAimBonus;
+
+var config int BondmateTargetAimBonus;
+var config int BondmateTargetCritBonus;
+
+simulated protected function OnEffectAdded(const out EffectAppliedData ApplyEffectParameters, XComGameState_BaseObject kNewTargetState, XComGameState NewGameState, XComGameState_Effect NewEffectState)
+{
+	super.OnEffectAdded(ApplyEffectParameters, kNewTargetState, NewGameState, NewEffectState);
+
+	BuildPersistentEffect(0, true);
+	SetDisplayInfo(ePerkBuff_Bonus, 
+					class'X2Ability_DefaultBondmateAbilities'.default.BondmateAimAdjustName, 
+					class'X2Ability_DefaultBondmateAbilities'.default.BondmateAimAdjustDesc, 
+					"img:///UILibrary_PerkIcons.UIPerk_aim");
+}
+
+function GetToHitModifiers(XComGameState_Effect EffectState, XComGameState_Unit Attacker, XComGameState_Unit Target, XComGameState_Ability AbilityState, class<X2AbilityToHitCalc> ToHitType, bool bMelee, bool bFlanking, bool bIndirectFire, out array<ShotModifierInfo> ShotModifiers)
+{
+	local StateObjectReference BondmateRef;
+	local XComGameState_Unit BondmateUnit;
+	local SoldierBond BondData;
+	local ShotModifierInfo ShotInfo;
+
+	if(!Attacker.HasSoldierBond(BondmateRef, BondData))
+	{
+		return;
+	}
+
+	BondmateUnit = XComGameState_Unit(`XCOMHISTORY.GetGameStateForObjectID(BondmateRef.ObjectID));
+	if(BondmateUnit == none)
+	{
+		return;
+	}
+
+	if (BondData.BondLevel >= 2 && IsBondmateThreatenedByTarget(BondmateUnit, Target))
+	{
+		ShotInfo.ModType = eHit_Success;
+		ShotInfo.Reason = class'X2Ability_DefaultBondmateAbilities'.default.DefendBondmateAimAdjustName;
+		ShotInfo.Value = ThreatenedBondmateAimBonus;
+		ShotModifiers.AddItem(ShotInfo);
+	}
+
+	if (BondData.BondLevel >= 3 && HasBondmateAttackedTargetSinceLastTurn(BondmateUnit, Target))
+	{
+		ShotInfo.ModType = eHit_Success;
+		ShotInfo.Reason = class'X2Ability_DefaultBondmateAbilities'.default.AssistBondmateAimAdjustName;;
+		ShotInfo.Value = BondmateTargetAimBonus;
+		ShotModifiers.AddItem(ShotInfo);
+
+		ShotInfo.ModType = eHit_Crit;
+		ShotInfo.Reason = class'X2Ability_DefaultBondmateAbilities'.default.AssistBondmateCritAdjustName;;
+		ShotInfo.Value = BondmateTargetCritBonus;
+		ShotModifiers.AddItem(ShotInfo);
+	}
+}
+
+protected function bool IsBondmateThreatenedByTarget(XComGameState_Unit BondmateUnit, XComGameState_Unit Target)
+{
+	local XComGameState_Ability AbilityState;
+	local X2AbilityTargetStyle TargetStyle;
+
+	// If the target flanks our bondmate, they are threatened
+	if(BondmateUnit.IsFlanked(Target.GetReference()))
+	{
+		return true;
+	}
+
+	// If the target can melee our bondmate, they are threatened
+	if(HasMeleeAbility(Target, AbilityState))
+	{
+		TargetStyle = AbilityState.GetMyTemplate().AbilityTargetStyle;
+		if(TargetStyle != none && TargetStyle.ValidatePrimaryTargetOption(AbilityState, Target, BondmateUnit))
+		{
+			return true;
+		}
+	}
+
+	// If the target attacked our bondmate in the last turn, they are threatened
+	if(HasTargetAttackedBuddySinceTheStartOfLastTurn(BondmateUnit, Target))
+	{
+		return true;
+	}
+
+	return false;
+}
+
+protected function bool HasMeleeAbility(XComGameState_Unit UnitState, out XComGameState_Ability MeleeAbility)
+{
+	local XComGameStateHistory History;
+	local StateObjectReference AbilityObjectRef;
+	local XComGameState_Ability AbilityState;
+
+	History = `XCOMHISTORY;
+
+	foreach UnitState.Abilities(AbilityObjectRef)
+	{
+		AbilityState = XComGameState_Ability(History.GetGameStateForObjectID(AbilityObjectRef.ObjectID));
+		if(AbilityState.GetMyTemplate().Hostility == eHostility_Offensive && AbilityState.IsMeleeAbility())
+		{
+			MeleeAbility = AbilityState;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+protected function bool HasTargetAttackedBuddySinceTheStartOfLastTurn(XComGameState_Unit BondmateUnit, XComGameState_Unit Target)
+{
+	local XComGameStateHistory History;
+	local XComGameState_Ability AbilityState;
+	local XComGameStateContext_TacticalGameRule RuleContext;
+	local XComGameStateContext_Ability AbilityContext;
+	local int StartOfLastTargetTurnIndex;
+
+	// Find the start of the target's last turn
+	StartOfLastTargetTurnIndex = 0;
+	History = `XCOMHISTORY;
+	foreach History.IterateContextsByClassType(class'XComGameStateContext_TacticalGameRule', RuleContext)
+	{
+		if(RuleContext.GameRuleType == eGameRule_PlayerTurnBegin && RuleContext.PlayerRef.ObjectID == Target.GetAssociatedPlayerID())
+		{
+			StartOfLastTargetTurnIndex = RuleContext.AssociatedState.HistoryIndex;
+			break;
+		}
+	}
+
+	// and then see if the target has attacked our buddy since then
+	foreach History.IterateContextsByClassType(class'XComGameStateContext_Ability', AbilityContext)
+	{
+		if(AbilityContext.AssociatedState.HistoryIndex < StartOfLastTargetTurnIndex)
+		{
+			return false;
+		}
+
+		if(AbilityContext.InputContext.SourceObject == Target.GetReference()
+			&& AbilityContext.InputContext.PrimaryTarget == BondmateUnit.GetReference())
+		{
+			AbilityState = XComGameState_Ability(History.GetGameStateForObjectID(AbilityContext.InputContext.AbilityRef.ObjectID));
+			if(AbilityState != none && AbilityState.GetMyTemplate().Hostility == eHostility_Offensive)
+			{
+				return true;
+			}
+		}
+	}
+
+	return true;
+}
+
+protected function bool HasBondmateAttackedTargetSinceLastTurn(XComGameState_Unit BondmateUnit, XComGameState_Unit Target)
+{
+	local XComGameStateHistory History;
+	local XComGameState_Ability AbilityState;
+	local XComGameStateContext_TacticalGameRule RuleContext;
+	local XComGameStateContext_Ability AbilityContext;
+	local int StartOfLastBondmateTurnIndex;
+
+	// Find the start of the target's last turn
+	StartOfLastBondmateTurnIndex = 0;
+	History = `XCOMHISTORY;
+	foreach History.IterateContextsByClassType(class'XComGameStateContext_TacticalGameRule', RuleContext)
+	{
+		if(RuleContext.GameRuleType == eGameRule_PlayerTurnBegin && RuleContext.PlayerRef.ObjectID == BondmateUnit.GetAssociatedPlayerID())
+		{
+			StartOfLastBondmateTurnIndex = RuleContext.AssociatedState.HistoryIndex;
+			break;
+		}
+	}
+
+	// and then see if the target has attacked our buddy since then
+	foreach History.IterateContextsByClassType(class'XComGameStateContext_Ability', AbilityContext)
+	{
+		if(AbilityContext.AssociatedState.HistoryIndex < StartOfLastBondmateTurnIndex)
+		{
+			return false;
+		}
+
+		if(AbilityContext.InputContext.SourceObject == BondmateUnit.GetReference()
+			&& AbilityContext.InputContext.PrimaryTarget == Target.GetReference())
+		{
+			AbilityState = XComGameState_Ability(History.GetGameStateForObjectID(AbilityContext.InputContext.AbilityRef.ObjectID));
+			if(AbilityState != none && AbilityState.GetMyTemplate().Hostility == eHostility_Offensive)
+			{
+				return true;
+			}
+		}
+	}
+
+	return true;
+}
+
+DefaultProperties
+{
+	DuplicateResponse = eDupe_Ignore
+	EffectName = "BondmateAimAdjust"
+}
\ No newline at end of file
diff --git a/SdkOverlay/XComGame/Classes/X2Effect_BondmateBleedout.uc b/SdkOverlay/XComGame/Classes/X2Effect_BondmateBleedout.uc
new file mode 100644
index 0000000..fb6023c
--- /dev/null
+++ b/SdkOverlay/XComGame/Classes/X2Effect_BondmateBleedout.uc
@@ -0,0 +1,21 @@
+//---------------------------------------------------------------------------------------
+//  Copyright (c) 2016 Firaxis Games, Inc. All rights reserved.
+//---------------------------------------------------------------------------------------
+class X2Effect_BondmateBleedout extends X2Effect_Persistent
+	config(GameCore);
+
+var config int BleedoutDurationAdjustment;
+
+function AdjustEffectDuration(const out EffectAppliedData ApplyEffectParameters, out int Duration)
+{
+	if(ApplyEffectParameters.EffectRef.LookupType == TELT_BleedOutEffect)
+	{
+		Duration += BleedoutDurationAdjustment;
+	}
+}
+
+defaultproperties
+{
+	EffectName="BondmateBleedout"
+	bEffectForcesBleedout=true
+}
\ No newline at end of file
diff --git a/SdkOverlay/XComGame/Classes/X2Effect_ChryssalidBurrowedAttack.uc b/SdkOverlay/XComGame/Classes/X2Effect_ChryssalidBurrowedAttack.uc
new file mode 100644
index 0000000..42b6dee
--- /dev/null
+++ b/SdkOverlay/XComGame/Classes/X2Effect_ChryssalidBurrowedAttack.uc
@@ -0,0 +1,75 @@
+//---------------------------------------------------------------------------------------
+//  Copyright (c) 2016 Firaxis Games, Inc. All rights reserved.
+//---------------------------------------------------------------------------------------
+class X2Effect_ChryssalidBurrowedAttack extends X2Effect_Persistent;
+
+var int NumActions;
+
+simulated protected function OnEffectAdded(const out EffectAppliedData ApplyEffectParameters, XComGameState_BaseObject kNewTargetState, XComGameState NewGameState, XComGameState_Effect NewEffectState)
+{
+	local XComGameState_Unit UnitState;
+	local XComGameState_AIGroup GroupState;
+	local XComGameState_Unit TargetUnitState;
+	
+	local XComWorldData WorldData;
+	local Vector OurVectorLocation;
+	local Vector ResultVectorLocation;
+	local TTile TargetFinalTile, OurTile, resultTile;
+	local bool bIsSpaceOccupiedAlready;
+	local StateObjectReference TargetObjectReference;
+
+	WorldData = `XWORLD;
+
+	super.OnEffectAdded(ApplyEffectParameters, kNewTargetState, NewGameState, NewEffectState);
+
+	UnitState = XComGameState_Unit(NewGameState.ModifyStateObject(class'XComGameState_Unit', ApplyEffectParameters.TargetStateObjectRef.ObjectID));
+
+	// This happens while it is not the unit's turn, so it should have no action points
+	// The unit must Unburrow and the Unburrow ability grants two action points
+	UnitState.ActionPoints.Length = 0;
+	UnitState.ActionPoints.AddItem(class'X2CharacterTemplateManager'.default.UnburrowActionPoint);
+	UnitState.ActionPoints.AddItem(class'X2CharacterTemplateManager'.default.StandardActionPoint);
+	UnitState.ActionPoints.AddItem(class'X2CharacterTemplateManager'.default.StandardActionPoint);
+
+	UnitState.bTriggerRevealAI = false;
+
+	// Mark group as scampered.
+	GroupState = UnitState.GetGroupMembership();
+	if( GroupState != none )
+	{
+		// No AI in MP
+		GroupState = XComGameState_AIGroup(NewGameState.ModifyStateObject(class'XComGameState_AIGroup', GroupState.ObjectID));
+		GroupState.bProcessedScamper = true;
+	}
+
+	`assert(ApplyEffectParameters.AbilityInputContext.MultiTargets.Length == 1); // Since the ability does a self target, the moved unit is now stored in the first multitarget index
+	TargetObjectReference = ApplyEffectParameters.AbilityInputContext.MultiTargets[0];
+	TargetUnitState = XComGameState_Unit(`XCOMHISTORY.GetGameStateForObjectID(TargetObjectReference.ObjectID));
+	XGUnit(UnitState.GetVisualizer()).m_kBehavior.PriorityTarget = TargetObjectReference; // Unit the Chryssalid will attack
+
+	if (TargetUnitState != none)
+	{
+		//if the target's final tile and our tile are the same, we need to move to a different Tile.
+		TargetFinalTile = TargetUnitState.TileLocation;
+		OurTile = UnitState.TileLocation;
+
+		bIsSpaceOccupiedAlready = (TargetFinalTile == OurTile);
+		if (bIsSpaceOccupiedAlready)
+		{
+			OurVectorLocation = WorldData.GetPositionFromTileCoordinates(OurTile);
+			ResultVectorLocation = WorldData.FindClosestValidLocation(OurVectorLocation, false, false, false);
+			resultTile = WorldData.GetTileCoordinatesFromPosition(ResultVectorLocation);
+			UnitState.SetVisibilityLocation(resultTile);
+		}
+	}
+
+	// Kick off panic behavior tree.
+	// Delayed behavior tree kick-off.  Points must be added and game state submitted before the behavior tree can 
+	// update, since it requires the ability cache to be refreshed with the new action points.
+	UnitState.AutoRunBehaviorTree('ChryssalidBurrowedAttack', NumActions, `XCOMHISTORY.GetCurrentHistoryIndex() + 1, true);
+}
+
+defaultproperties
+{
+	NumActions=3
+}
\ No newline at end of file
diff --git a/SdkOverlay/XComGame/Classes/X2Effect_CombatStims.uc b/SdkOverlay/XComGame/Classes/X2Effect_CombatStims.uc
new file mode 100644
index 0000000..5941070
--- /dev/null
+++ b/SdkOverlay/XComGame/Classes/X2Effect_CombatStims.uc
@@ -0,0 +1,27 @@
+class X2Effect_CombatStims extends X2Effect_BonusArmor config(GameCore);
+
+var config int ARMOR_CHANCE, ARMOR_MITIGATION;
+var array<name> DamageTypeImmunities;
+
+function bool ProvidesDamageImmunity(XComGameState_Effect EffectState, name DamageType)
+{
+	if( DamageTypeImmunities.Find(DamageType) != INDEX_NONE )
+	{
+		return true;
+	}
+	return false;
+}
+
+function int GetArmorChance(XComGameState_Effect EffectState, XComGameState_Unit UnitState) { return default.ARMOR_CHANCE; }
+function int GetArmorMitigation(XComGameState_Effect EffectState, XComGameState_Unit UnitState) { return default.ARMOR_MITIGATION; }
+
+DefaultProperties
+{
+	EffectName="CombatStims"
+	DuplicateResponse=eDupe_Refresh
+	DamageTypeImmunities(0)="Mental"
+	DamageTypeImmunities(1)="Disorient"
+	DamageTypeImmunities(2)="stun"
+	DamageTypeImmunities(3)="Unconscious"
+	DamageTypeImmunities(4)="psi"
+}
\ No newline at end of file
diff --git a/SdkOverlay/XComGame/Classes/X2Effect_MimicBeacon.uc b/SdkOverlay/XComGame/Classes/X2Effect_MimicBeacon.uc
new file mode 100644
index 0000000..801fa36
--- /dev/null
+++ b/SdkOverlay/XComGame/Classes/X2Effect_MimicBeacon.uc
@@ -0,0 +1,82 @@
+class X2Effect_MimicBeacon extends X2Effect_Persistent config(GameCore);
+
+var config array<name> ABILITIES_ALLOWED_TO_HIT;
+var private config name REMOVE_EFFECT_ANIM_NAME;
+
+function ModifyTurnStartActionPoints(XComGameState_Unit UnitState, out array<name> ActionPoints, XComGameState_Effect EffectState)
+{
+	ActionPoints.Length = 0;
+}
+
+simulated function OnEffectRemoved(const out EffectAppliedData ApplyEffectParameters, XComGameState NewGameState, bool bCleansed, XComGameState_Effect RemovedEffectState)
+{
+	local XComGameState_Unit MimicUnit;
+
+	super.OnEffectRemoved(ApplyEffectParameters, NewGameState, bCleansed, RemovedEffectState);
+
+	MimicUnit = XComGameState_Unit(`XCOMHISTORY.GetGameStateForObjectID(ApplyEffectParameters.TargetStateObjectRef.ObjectID));
+	if( MimicUnit != None )
+	{
+		MimicUnit = XComGameState_Unit(NewGameState.ModifyStateObject(class'XComGameState_Unit', MimicUnit.ObjectID));
+
+		// Remove the dead unit from play
+		`XEVENTMGR.TriggerEvent('UnitRemovedFromPlay', MimicUnit, MimicUnit, NewGameState);
+	}
+}
+
+simulated function AddX2ActionsForVisualization_Removed(XComGameState VisualizeGameState, out VisualizationActionMetadata ActionMetadata, const name EffectApplyResult, XComGameState_Effect RemovedEffect)
+{
+	local X2Action_MimicBeaconEnd MimicEndAction;
+	local XComGameState_Unit UnitState;
+
+	super.AddX2ActionsForVisualization_Removed(VisualizeGameState, ActionMetadata, EffectApplyResult, RemovedEffect);
+
+	if (EffectApplyResult != 'AA_Success' || ActionMetadata.VisualizeActor == none)
+	{
+		return;
+	}
+
+	MimicEndAction = X2Action_MimicBeaconEnd(class'X2Action_MimicBeaconEnd'.static.AddToVisualizationTree(ActionMetadata, VisualizeGameState.GetContext(), false, ActionMetadata.LastActionAdded));
+
+	UnitState = XComGameState_Unit(ActionMetadata.StateObject_OldState);
+	if( (UnitState != none) && UnitState.IsAlive() )
+	{
+		MimicEndAction.AnimationName = default.REMOVE_EFFECT_ANIM_NAME;
+	}
+}
+
+simulated function AddX2ActionsForVisualization_Sync( XComGameState VisualizeGameState, out VisualizationActionMetadata ActionMetadata )
+{
+	local X2Action_PlayAnimation AnimationAction;
+
+	super.AddX2ActionsForVisualization_Sync(VisualizeGameState, ActionMetadata);
+
+	AnimationAction = X2Action_PlayAnimation(class'X2Action_PlayAnimation'.static.AddToVisualizationTree(ActionMetadata, VisualizeGameState.GetContext(), false, ActionMetadata.LastActionAdded));
+	AnimationAction.Params.AnimName = class'X2Ability_ItemGrantedAbilitySet'.default.MIMIC_BEACON_START_ANIM;
+	AnimationAction.Params.BlendTime = 0.0f;
+}
+
+function bool ProvidesDamageImmunity(XComGameState_Effect EffectState, name DamageType)
+{
+	return DamageType == 'poison' ||
+		   DamageType == 'fire' ||
+		   DamageType == 'acid' ||
+		   DamageType == class'X2Item_DefaultDamageTypes'.default.KnockbackDamageType ||
+		   DamageType == 'psi' ||
+		   DamageType == class'X2Item_DefaultDamageTypes'.default.ParthenogenicPoisonType ||
+		   DamageType == 'stun';
+}
+
+function bool CanAbilityHitUnit(name AbilityName)
+{
+	return ABILITIES_ALLOWED_TO_HIT.Find(AbilityName) != INDEX_NONE;
+}
+
+function bool DoesEffectAllowUnitToBleedOut(XComGameState_Unit UnitState) {return false; }
+function bool DoesEffectAllowUnitToBeLooted(XComGameState NewGameState, XComGameState_Unit UnitState) {return false; }
+
+DefaultProperties
+{
+	DuplicateResponse = eDupe_Ignore
+	EffectName = "MimicBeaconEffect"
+}
\ No newline at end of file
diff --git a/SdkOverlay/XComGame/Classes/X2Effect_Solace.uc b/SdkOverlay/XComGame/Classes/X2Effect_Solace.uc
new file mode 100644
index 0000000..83d94c5
--- /dev/null
+++ b/SdkOverlay/XComGame/Classes/X2Effect_Solace.uc
@@ -0,0 +1,82 @@
+class X2Effect_Solace extends X2Effect_Persistent;
+
+var array<name> DamageTypeImmunities;
+
+function bool IsEffectCurrentlyRelevant(XComGameState_Effect EffectGameState, XComGameState_Unit TargetUnit)
+{
+	local XComGameState_Unit SourceUnit;
+
+	SourceUnit = XComGameState_Unit(`XCOMHISTORY.GetGameStateForObjectID(EffectGameState.ApplyEffectParameters.SourceStateObjectRef.ObjectID));
+	
+	if (SourceUnit == none || SourceUnit.IsDead() || TargetUnit == none || TargetUnit.IsDead())
+		return false;
+
+	if (SourceUnit.ObjectID != TargetUnit.ObjectID)
+	{
+		//  jbouscher: uses tile range rather than unit range so the visual check can match this logic
+		if (!class'Helpers'.static.IsTileInRange(SourceUnit.TileLocation, TargetUnit.TileLocation, class'X2Ability_PsiOperativeAbilitySet'.default.SOLACE_DISTANCE_SQ))
+			return false;
+	}
+
+	return true;
+}
+
+function bool ProvidesDamageImmunity(XComGameState_Effect EffectState, name DamageType)
+{
+	local XComGameState_Unit TargetUnit;
+
+	if (DamageTypeImmunities.Find(DamageType) != INDEX_NONE)
+	{
+		TargetUnit = XComGameState_Unit(`XCOMHISTORY.GetGameStateForObjectID(EffectState.ApplyEffectParameters.TargetStateObjectRef.ObjectID));
+		return IsEffectCurrentlyRelevant(EffectState, TargetUnit);
+	}
+	return false;
+}
+
+function OnUnitChangedTile(const out TTile NewTileLocation, XComGameState_Effect EffectState, XComGameState_Unit TargetUnit)
+{
+	local XComGameStateHistory History;
+	local XComGameState_Unit SourceUnit;
+	local XComGameState_Effect OtherEffect;
+	local bool bAddTarget;
+	local int i;
+
+	History = `XCOMHISTORY;
+	if (TargetUnit.ObjectID != EffectState.ApplyEffectParameters.SourceStateObjectRef.ObjectID)
+	{
+		SourceUnit = XComGameState_Unit(History.GetGameStateForObjectID(EffectState.ApplyEffectParameters.SourceStateObjectRef.ObjectID));
+		if (SourceUnit != none && SourceUnit.IsAlive() && TargetUnit.IsAlive())
+		{
+			bAddTarget = class'Helpers'.static.IsTileInRange(SourceUnit.TileLocation, NewTileLocation, class'X2Ability_PsiOperativeAbilitySet'.default.SOLACE_DISTANCE_SQ);
+			EffectState.UpdatePerkTarget(bAddTarget);
+		}
+	}
+	else
+	{
+		//  When the source moves, check all other targets and update them
+		SourceUnit = TargetUnit;
+		for (i = 0; i < EffectState.ApplyEffectParameters.AbilityInputContext.MultiTargets.Length; ++i)
+		{
+			if (EffectState.ApplyEffectParameters.AbilityInputContext.MultiTargets[i].ObjectID != SourceUnit.ObjectID)
+			{
+				TargetUnit = XComGameState_Unit(History.GetGameStateForObjectID(EffectState.ApplyEffectParameters.AbilityInputContext.MultiTargets[i].ObjectID));
+				OtherEffect = TargetUnit.GetUnitAffectedByEffectState(default.EffectName);
+				if (OtherEffect != none)
+				{
+					bAddTarget = class'Helpers'.static.IsTileInRange(NewTileLocation, TargetUnit.TileLocation, class'X2Ability_PsiOperativeAbilitySet'.default.SOLACE_DISTANCE_SQ);
+					OtherEffect.UpdatePerkTarget(bAddTarget);
+				}
+			}
+		}
+	}
+}
+
+DefaultProperties
+{
+	EffectName="Solace"
+	DuplicateResponse=eDupe_Ignore
+	DamageTypeImmunities(0)="Mental"
+	DamageTypeImmunities(1)="Disorient"
+	DamageTypeImmunities(2)="stun"
+	DamageTypeImmunities(3)="Unconscious"
+}
\ No newline at end of file
diff --git a/docs/contributing/adding-an-editor.md b/docs/contributing/adding-an-editor.md
index 2d9f9cd..714d77d 100644
--- a/docs/contributing/adding-an-editor.md
+++ b/docs/contributing/adding-an-editor.md
@@ -3,22 +3,35 @@
 This page is for people working on Ability Editor itself. To extend it *from another mod* without
 forking, see [Bridge mods](../guides/bridge-mods.md) instead.
 
-## Build prerequisite: Community Highlander sources
+## Build prerequisites
 
-**Building this mod may require changes to the SDK to unprotect properties. Or simply have `Development/SrcOrig` up to date with Community Highlander-patched.**. It is not a requirement for players.
+UnrealScript access modifiers (`private`, `protected`, `privatewrite`, `const`) exist only at
+compile time. Compiling against relaxed sources runs against the stock game.
+This mod relies on that twice. Neither is a requirement for players.
+
+### Community Highlander sources
 
 `X2AbilityEffectsEditor_Helper.uc` writes `Template.AbilityTargetEffects`,
 `AbilityMultiTargetEffects` and `AbilityShooterEffects`. In stock Firaxis sources those three are
 `protectedwrite`, so the writes will not compile. Community Highlander
 [Issue #68](https://github.com/X2CommunityCore/X2WOTCCommunityHighlander/issues/68) removes that
-modifier.
-
-This is a compile-time dependency only. The issue changes nothing but the accessibility modifier -
-same types, same declaration order, same class layout - and UnrealScript access modifiers do not
-affect the compiled property layout, so the resulting `.u` runs against vanilla `XComGame` too.
+modifier; `Development/SrcOrig` must be the Highlander-patched copy.
 
 If a build fails with `Can't write to protected variable` on `AbilityTargetEffects`, your SDK
-sources are stock; either unprotect the variable or deploy the Highlander into the SDK.
+sources are stock: deploy the Highlander into the SDK.
+
+### Relaxing fields
+
+A few game fields are `private` or `protected const` and have no setter. Rather than patching the
+SDK by hand before every build, `SdkOverlay/XComGame/Classes/` holds verbatim copies of those
+classes with only the modifier relaxed, and `build.ps1` registers the folder with `X2ModBuildCommon`'s `IncludeSrc`.
+
+To write such a field from a new editor: copy the class from `Development/SrcOrig` into the
+overlay, change only the modifier on the field you write, add a row to `SdkOverlay/README.md`, and
+write the editor as usual. If a Highlander release changes one of those classes, refresh the copy.
+
+The overlay cannot help with a field the game reads as `default.X` - see
+[Why isn't this editable?](coverage-triage.md).
 
 ## The four places
 
diff --git a/docs/contributing/coverage-triage.md b/docs/contributing/coverage-triage.md
new file mode 100644
index 0000000..99865b4
--- /dev/null
+++ b/docs/contributing/coverage-triage.md
@@ -0,0 +1,99 @@
+# Why isn't this editable?
+
+Some game classes have fields that will never get an editor, because an editor could not
+change anything. This page records which, and why.
+
+## Read from the class default, not the instance
+
+This is the largest group. An editor writes the ability template's *instance* of an effect.
+If the game reads the field as `default.X`, it is reading the class default from `XComGameCore.ini` and never looks at the instance. The edit is applied, logged, and ignored.
+
+```unrealscript
+// X2Effect_Vengeance.uc:43 - every one of its 11 config ints reads this way
+StatChance = default.STAT_BASE_CHANCE + DeadRank * default.STAT_PER_RANK_CHANCE;
+```
+
+These fields are not unreachable. They are already tunable, **globally**, in the game's own
+config, and that is the right place to change them:
+
+```ini
+[XComGame.X2Effect_Vengeance]
+AIM_BASE=10
+```
+
+What an editor would add is *per-ability* control, which the code does not support for these fields.
+Adding it would need a global-scope edit family.
+
+| Class | Fields read via `default.` | Where |
+|---|---|---|
+| `X2Effect_Vengeance` | all 11 config ints | `X2Effect_Vengeance.uc` |
+| `X2Effect_CombatStims` | `ARMOR_CHANCE`, `ARMOR_MITIGATION` | `X2Effect_CombatStims.uc` |
+| `X2Effect_IncendiaryRounds` | `AimMod` | `X2Effect_IncendiaryRounds.uc` |
+| `X2Effect_TracerRounds` | `AimMod` | `X2Effect_TracerRounds.uc` |
+| `X2Effect_ApplyPoisonToWorld` | `Duration` (the particle name *is* editable) | `X2Effect_ApplyPoisonToWorld.uc` |
+| `X2Effect_ApplySmokeGrenadeToWorld` | `Duration` (the particle name *is* editable) | `X2Effect_ApplySmokeGrenadeToWorld.uc` |
+| `X2Effect_Deflect` | 5 config ints | |
+| `X2Effect_Marked` | 3 config ints | |
+| `X2Effect_Shredder` | `ConventionalShred`, `MagneticShred`, `BeamShred` | |
+| `X2Effect_Suppression` | 3 aim penalties | |
+| `X2Effect_ZeroIn` | `CritPerShot`, `LockedInAimPerShot` | |
+| `X2Effect_BiggestBooms` | `CRIT_CHANCE_BONUS`, `CRIT_DAMAGE_BONUS` | |
+| `X2Effect_Frenzy` | `FRENZY_NUM_ACTION_POINTS_ADDED` | |
+| `X2Effect_AidProtocol` | `BASE_DEFENSE` | |
+| `X2Effect_Dazed` | `DAZE_REMOVE_EFFECTS_TARGET` | |
+| `X2Effect_TheLostHeadshot` | `ValidHeadshotAbilities` | |
+| `X2Effect_Blind` | `BlindStatusIcon` | |
+| `X2Effect_Burrowed` | `BURROWED_PERCENT_DAMAGE_REDUCTION` | |
+| `X2Effect_GatekeeperClosed` | `GATEKEEPER_CLOSED_PERCENT_DAMAGE_REDUCTION` | |
+| `X2Effect_ProximityMine` | `PersistentParticles` | |
+| `X2Effect_DisableWeapon` | `HideVisualizationOfResults`, `WeaponsImmuneToDisable` | |
+| `X2Effect_SkirmisherReflex` | `ReflexUnitValue`, `TotalEarnedValue` | `X2Effect_SkirmisherReflex.uc`, `XComGameState_Effect.uc` |
+| `X2Effect_TargetDefinition` | `TargetDefinitionTriggeredEventName` | |
+| `X2Effect_MimicBeacon` | `REMOVE_EFFECT_ANIM_NAME` (`ABILITIES_ALLOWED_TO_HIT` *is* editable) | |
+| `X2Effect_SpectralArmyUnit` | `ADD_EFFECT_ANIM_NAME`, `REMOVE_EFFECT_ANIM_NAME` | |
+| `X2Effect_Reaper` | `ReaperActivatedName`, `ReaperKillName` | |
+| `X2Effect_ScanningProtocol` | `LookAtDuration` | |
+| `X2Effect_ParthenogenicPoison` | `ParthenogenicPoisonType`, `ParthenogenicPoisonCocoonSpawnedName` (`AltUnitToSpawnName` *is* editable) | `X2Effect_ParthenogenicPoison.uc`, `X2Ability_DefaultAbilitySet.uc` |
+
+!!! note "`X2Effect_CombatStims` is worse"
+    It overrides `GetArmorMitigation()` to return `default.ARMOR_MITIGATION`. So the `ArmorMitigationAmount` field it *inherits* from the BonusArmor editor is silently ignored too
+    An entry naming `X2Effect_CombatStims` and setting `ArmorMitigationAmount` applies cleanly and does nothing.
+
+## Never read at all
+
+| Class | Field | Evidence |
+|---|---|---|
+| `X2AbilityToHitCalc_StasisLance` | `HP_THRESHOLD`, `CLAMPED_MIN`, `CLAMPED_MAX` | only inside commented-out code. `BASE_CHANCE` is live but `default.`-read. |
+| `X2AbilityMultiTarget_Volt` | `DistanceBetweenTargets` | not referenced in the SDK. |
+
+## No plain field to write
+
+There is no assignment an editor could make. An editor would have to call the setter, or map a
+config name to a delegate.
+
+| Class | Route |
+|---|---|
+| `X2Effect_AdditionalAnimSets` | `AddAnimSetWithPath(string)` - append-only, no way to clear |
+| `X2AbilityTrigger_OnAbilityActivated` | `SetListenerData(name)` - also overwrites `ListenerData.EventID/EventFn/Deferral/Filter`, so it resets the whole listener |
+| `X2Effect_Unkillable` | `AdditionalEffectsFN` delegate |
+| `X2Effect_WeakPoint` | `GetValueFn` delegate |
+
+## Deliberately skipped
+
+| Class | Why |
+|---|---|
+| `X2Effect_Panicked`, `X2Effect_Executed`, `X2Effect_SpawnGhost` | Localised strings only. That belongs in a localisation file, not an ability edit. |
+| `X2Condition_Wrath` | `TargetTile` is runtime scratch, set by `X2Effect_GetOverThere` when applied. |
+| `X2Effect_CallReinforcements` | `m_kAudioEvent` is an `AkEvent` object reference. Would need `DynamicLoadObject`. |
+
+## Editable, despite appearances
+
+**`X2Effect_Burning`** has no editor of its own and does not need one. Its only settable var, `BURNED_IGNORES_SHIELDS`, is consumed inside `SetBurnDamage()` at template-build time, before this mod runs.
+Its duration and removal rules come from the `X2Effect_Persistent` editor it falls through to, and its *damage* lives in a nested `X2Effect_ApplyWeaponDamage` at `ApplyOnTick[0]`, reachable with `ApplyOnTickClass` - see [Examples](../guides/examples.md#change-how-much-damage-burning-does).
+
+**`X2AbilityCooldown` and `X2AbilityCharges`** are the only two family base classes that are themselves concrete.
+Neither has an `IsA` editor, but their own vars are written by `ApplyBaseEdit` in the abstract family editor, reached through the `_Base` catch-all.
+
+**`private`, `protected` and `const` fields.** UnrealScript access modifiers exist only at compile time.
+The build compiles against an [SDK overlay](adding-an-editor.md#relaxing-fields) that relaxes the few this mod writes, so `X2Effect_Solace.DamageTypeImmunities`, `X2Effect_BondmateAimAdjust`'s three bonuses and the like have ordinary editors.
+What the overlay cannot fix is a `default.` read.
diff --git a/docs/guides/examples.md b/docs/guides/examples.md
index 9731f51..07158a6 100644
--- a/docs/guides/examples.md
+++ b/docs/guides/examples.md
@@ -123,6 +123,56 @@ targets.
 The template-level `TargetConditions` edits the existing `X2Condition_UnitProperty` **in place** if
 the ability has one - changing only the fields you `Set` - and adds a new one otherwise.
 
+## Change how much damage burning does
+
+Damage-over-time effects are two objects, not one. `X2Effect_Burning` is the *state* — how
+long it lasts, what removes it — while the damage itself lives in an
+`X2Effect_ApplyWeaponDamage` nested in the parent's `ApplyOnTick` list. Editing the burning
+effect directly only reaches the first half.
+
+`ApplyOnTickClass` redirects an entry at the child, so the rest of the entry edits that
+instead:
+
+```ini
++AbilityEdits=( \\
+    Ability=ThrowMolotov, \\
+    Effects=( \\
+        ( \\
+            Class="X2Effect_Burning", \\
+            Mode=eAEM_Merge, \\
+            SetNumTurns=true, \\
+            NumTurns=3 \\
+        ), \\
+        ( \\
+            Class="X2Effect_Burning", \\
+            Mode=eAEM_Merge, \\
+            ApplyOnTickClass="X2Effect_ApplyWeaponDamage", \\
+            ApplyOnTickMode=eAEM_Merge, \\
+            WeaponDamageValue=( \\
+                SetDamage=true, \\
+                Damage=5, \\
+                SetSpread=true, \\
+                Spread=2 \\
+            ) \\
+        ) \\
+    ) \\
+)
+```
+
+Two entries for one effect: the first sets the duration on the burning state, the second
+reaches through it to the damage. Both name the same `Class`, because both are addressing
+the same parent — the second just redirects before editing.
+
+This works for any persistent effect with a tick child, not just burning. Poisoned and
+bleeding use `X2Effect_ApplyWeaponDamage` the same way; Steady Hands nests an
+`X2Effect_PersistentStatChange`, and Void Conduit an `X2Effect_VoidConduit`. Whatever the
+child class is, it is dispatched to its own editor, so it accepts that class's fields.
+
+!!! warning "Crit and graze are suppressed on tick damage"
+    The game branches on `ApplyOnTickIndex` when applying damage, so damage delivered by a
+    tick never crits or grazes. Setting crit fields on a tick child will not do what the
+    same fields do on a normal damage effect.
+
 ## Tweak aim and targeting shape
 
 Give an ability +15 built-in aim and widen its cone. No `Class` on either block, so both edit
diff --git a/docs/guides/troubleshooting.md b/docs/guides/troubleshooting.md
index ef3ee05..cd8d10f 100644
--- a/docs/guides/troubleshooting.md
+++ b/docs/guides/troubleshooting.md
@@ -59,23 +59,18 @@ ability's old values.
 
 Some things genuinely cannot be edited per ability:
 
-- **The field is `config` on the game class.** It is read from the game's own `.ini`, not from the
-  template, so it is global rather than per-ability. Set it in your own mod's `XComGameCore.ini`
-  instead. For example:
+- **The game reads the field from the class default, not from the ability.** Usually the field is
+  `config` on the game class and read as `default.X`. Editing the template's copy changes nothing,
+  because the game never looks at it. These fields are global by design: set them in your own mod's
+  `XComGameCore.ini` instead. For example:
 
   ```ini
-  [XComGame.X2Effect_BondmateAimAdjust]
-  ThreatenedBondmateAimBonus=10
-  BondmateTargetAimBonus=20
-  BondmateTargetCritBonus=0
-
-  [XComGame.X2Effect_BondmateBleedout]
-  BleedoutDurationAdjustment=2
+  [XComGame.X2Effect_Vengeance]
+  AIM_BASE=10
   ```
 
-- **The field is read via the class default rather than the instance.** Editing the template's copy
-  changes nothing because the game never reads it. These are listed as *not editable* on the
-  relevant reference page, with the reason.
+  The reference pages list them as *not editable*, with the reason;
+  [Why isn't this editable?](../contributing/coverage-triage.md) has the full list.
 
 - **The behaviour lives in native code or in a different config file entirely.** Fire's
   tile-to-tile spread is one of these: it is native, and the only knob is the global
diff --git a/docs/schema.json b/docs/schema.json
index 2044467..b335e2c 100644
--- a/docs/schema.json
+++ b/docs/schema.json
@@ -1,6 +1,6 @@
 {
   "$comment": "Generated by .scripts/generate-docs.ps1 - do not edit by hand.",
-  "sourceHash": "7cfb2e78f5a7c80c370c9c98ea1041fb4b4127066e0665b42a7523c93a4afa96",
+  "sourceHash": "58f9fd6b5282cae557ba872218276c075ae3237d8f7fa03bf3b5e4a622091341",
   "enums": [
     {
       "name": "EStatChangeMode",
@@ -136,7 +136,7 @@
           "name": "NumTurns",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cooldown applied to that other ability, in turns.",
           "guard": "SetNumTurns"
         },
         {
@@ -191,42 +191,42 @@
           "name": "FreeCost",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
           "guard": "SetFreeCost"
         },
         {
           "name": "NumPoints",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Action points the ability consumes.",
           "guard": "SetNumPoints"
         },
         {
           "name": "AddWeaponTypicalCost",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Adds the weapon's own typical action cost on top of NumPoints.",
           "guard": "SetAddWeaponTypicalCost"
         },
         {
           "name": "ConsumeAllPoints",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ends the turn by consuming every remaining action point, rather than just NumPoints.",
           "guard": "SetConsumeAllPoints"
         },
         {
           "name": "MoveCost",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Treats the cost as movement, so effects and abilities that key off moving apply.",
           "guard": "SetMoveCost"
         },
         {
           "name": "AllowedTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Action point types that may pay this cost. Restricting it stops the ability being paid for with, say, a Run-and-Gun point.",
           "modeField": "AllowedTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -240,7 +240,7 @@
           "name": "DoNotConsumeAllEffects",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "If the user is under any of these effects, ConsumeAllPoints is ignored and the turn does not end.",
           "modeField": "DoNotConsumeAllEffectsMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -254,7 +254,7 @@
           "name": "DoNotConsumeAllSoldierAbilities",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "If the user has any of these abilities, ConsumeAllPoints is ignored. This is how Blademaster lets Slash keep the turn going.",
           "modeField": "DoNotConsumeAllSoldierAbilitiesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -268,7 +268,7 @@
           "name": "SharedAbilityCharges",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Other abilities whose charges are spent alongside this one, as Skulljack and Skullmine share a pool. Applied when paying, never when checking affordability.",
           "modeField": "SharedAbilityChargesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -282,70 +282,70 @@
           "name": "FocusAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Templar focus consumed.",
           "guard": "SetFocusAmount"
         },
         {
           "name": "ConsumeAllFocus",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Spends the user's entire focus pool rather than FocusAmount.",
           "guard": "SetConsumeAllFocus"
         },
         {
           "name": "GhostOnlyCost",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only charges focus to a Ghost, leaving the original Templar's pool untouched.",
           "guard": "SetGhostOnlyCost"
         },
         {
           "name": "NumAmmo",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ammo consumed per use. With ConsumeAllAmmo set this becomes the minimum needed to fire, rather than the amount spent.",
           "guard": "SetNumAmmo"
         },
         {
           "name": "UseLoadedAmmo",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Draws from the loaded grenade rather than the weapon's ammo, for grenade-launcher abilities.",
           "guard": "SetUseLoadedAmmo"
         },
         {
           "name": "ReturnChargesError",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reports a shortfall as \"out of charges\" instead of \"out of ammo\", for abilities presented to the player as charge-based.",
           "guard": "SetReturnChargesError"
         },
         {
           "name": "ConsumeAllAmmo",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Spends the whole magazine. NumAmmo then only sets the minimum required to fire.",
           "guard": "SetConsumeAllAmmo"
         },
         {
           "name": "NumCharges",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Charges consumed per use.",
           "guard": "SetNumCharges"
         },
         {
           "name": "OnlyOnHit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only spends the charge when the ability hits, so a miss costs nothing.",
           "guard": "SetOnlyOnHit"
         },
         {
           "name": "AlsoExpendChargesOnSharedBondmateAbility",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Also spends the bondmate's charges of the shared ability.",
           "guard": "SetAlsoExpendChargesOnSharedBondmateAbility"
         }
       ]
@@ -363,14 +363,14 @@
           "name": "NumTurns",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Turns the ability is unavailable after use.",
           "guard": "SetNumTurns"
         },
         {
           "name": "IgnoreOnHit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
           "guard": "SetIgnoreOnHit"
         },
         {
@@ -383,7 +383,7 @@
           "name": "AdditionalCooldowns",
           "type": "array<AdditionalCooldownEdit>",
           "kind": "nested",
-          "description": "",
+          "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
           "modeField": "AdditionalCooldownMode",
           "modeEnum": "EAdditionalCooldownEditMode"
         },
@@ -391,14 +391,14 @@
           "name": "NumTurnsForAI",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cooldown used when the unit is AI-controlled, letting XCOM and the enemy run different timings. Only on X2AbilityCooldown_PerPlayerType.",
           "guard": "SetNumTurnsForAI"
         },
         {
           "name": "NumGlobalTurns",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cooldown applied across every unit on the team, not just the one that used the ability. Only on the global cooldown classes.",
           "guard": "SetNumGlobalTurns"
         }
       ]
@@ -416,7 +416,7 @@
           "name": "InitialCharges",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Charges the ability starts a mission with.",
           "guard": "SetInitialCharges"
         },
         {
@@ -429,7 +429,7 @@
           "name": "BonusCharges",
           "type": "array<BonusChargeEdit>",
           "kind": "nested",
-          "description": "",
+          "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
           "modeField": "BonusChargesMode",
           "modeEnum": "EChargesBonusMode"
         },
@@ -443,7 +443,7 @@
           "name": "Stabilize",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the charges behave as the stabilise-style pool, on the charge classes that support it.",
           "guard": "SetStabilize"
         }
       ]
@@ -490,7 +490,7 @@
           "name": "OwnerHasSoldierAbilities",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Soldier abilities the unit owning the ability must have.",
           "modeField": "OwnerHasSoldierAbilitiesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -498,91 +498,105 @@
           "name": "TargetMustBeInValidTiles",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject targets standing outside the ability's valid tiles.",
           "guard": "SetTargetMustBeInValidTiles"
         },
         {
           "name": "WantsReload",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail with AA_AmmoAlreadyFull when the source weapon's clip is already full.",
           "guard": "SetWantsReload"
         },
         {
           "name": "CheckAmmo",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Compare the source weapon's ammo against CheckAmmoData.",
           "guard": "SetCheckAmmo"
         },
         {
           "name": "CheckAmmoData",
           "type": "CheckConfig",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "The ammo check used when CheckAmmo is true: Value, CheckType, and ValueMin/ValueMax for range checks.",
           "guard": "SetCheckAmmoData"
         },
         {
           "name": "NotLoadedAmmoInSecondaryWeapon",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail when the source weapon is currently loaded as ammo in the secondary weapon.",
           "guard": "SetNotLoadedAmmoInSecondaryWeapon"
         },
         {
           "name": "MatchGrenadeType",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Grenade template the source weapon, or its loaded ammo, must be.",
           "guard": "SetMatchGrenadeType"
         },
         {
           "name": "CheckGrenadeFriendlyFire",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject friendly targets unless the grenade template allows friendly fire.",
           "guard": "SetCheckGrenadeFriendlyFire"
         },
         {
           "name": "CheckAmmoTechLevel",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject the source ammo when it is not valid for the unit's primary weapon.",
           "guard": "SetCheckAmmoTechLevel"
         },
         {
           "name": "MatchWeaponTemplate",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Weapon template the source weapon must be, exact match on its DataName.",
           "guard": "SetMatchWeaponTemplate"
         },
         {
           "name": "StilettoRounds",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Pass only while the Stiletto Rounds dark event is active.",
           "guard": "SetStilettoRounds"
         },
         {
           "name": "RequiredGameplayTag",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Tactical gameplay tag XCOM HQ must carry for the ability to be valid.",
           "guard": "SetRequiredGameplayTag"
         },
         {
           "name": "DisallowGameplayTag",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Tactical gameplay tag that makes the ability invalid while XCOM HQ carries it.",
           "guard": "SetDisallowGameplayTag"
         },
+        {
+          "name": "HourChecksMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Condition_GameTime"
+        },
+        {
+          "name": "HourChecks",
+          "type": "array<CheckConfig>",
+          "kind": "modedArray",
+          "description": "Checks against the current hour of the day; the condition passes when any one of them does. Merge adds checks not already present.",
+          "modeField": "HourChecksMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "NumTurnsCheck",
           "type": "CheckConfig",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Check against the number of turns the target's controlling player has taken.",
           "guard": "SetNumTurnsCheck"
         },
         {
@@ -595,7 +609,7 @@
           "name": "ActionPointChecks",
           "type": "array<ActionPointCheck>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Action point checks; passes when any one of them does. Each names an action point type, whether to count reserved points, and the value check.",
           "modeField": "ActionPointChecksMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -603,14 +617,14 @@
           "name": "RequiredAlertStatusMaximum",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Highest alert level the unit may have. -1 ignores it; the condition fails when both limits are -1.",
           "guard": "SetRequiredAlertStatusMaximum"
         },
         {
           "name": "RequiredAlertStatusMinimum",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lowest alert level the unit may have. -1 ignores it; the condition fails when both limits are -1.",
           "guard": "SetRequiredAlertStatusMinimum"
         },
         {
@@ -623,7 +637,7 @@
           "name": "ExcludeEffects",
           "type": "array<EffectReason>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effects that reject the unit when present, each with the failure reason to return.",
           "modeField": "ExcludeEffectsMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -637,7 +651,7 @@
           "name": "RequireEffects",
           "type": "array<EffectReason>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effects that must all be present on the unit, each with the failure reason to return.",
           "modeField": "RequireEffectsMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -651,7 +665,7 @@
           "name": "ExcludeDamageTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Damage types; a unit immune to any of them is rejected.",
           "modeField": "ExcludeDamageTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -659,329 +673,329 @@
           "name": "OnlyOnCharacterTemplate",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Consider only the immunities of the unit's character template, not those granted by effects.",
           "guard": "SetOnlyOnCharacterTemplate"
         },
         {
           "name": "InteractionType",
           "type": "UnitInterationType",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Kind of interaction point the unit must be next to: eInteractionType_Normal or eInteractionType_Hack.",
           "guard": "SetInteractionType"
         },
         {
           "name": "RelevantSlot",
           "type": "EInventorySlot",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Inventory slot whose item is checked.",
           "guard": "SetRelevantSlot"
         },
         {
           "name": "ExcludeWeaponCategory",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Weapon category that rejects the unit when the item in RelevantSlot has it.",
           "guard": "SetExcludeWeaponCategory"
         },
         {
           "name": "RequireWeaponCategory",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Weapon category the item in RelevantSlot must have. Fails when the slot is empty.",
           "guard": "SetRequireWeaponCategory"
         },
         {
           "name": "ExcludeAlive",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject living units.",
           "guard": "SetExcludeAlive"
         },
         {
           "name": "ExcludeDead",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject dead units.",
           "guard": "SetExcludeDead"
         },
         {
           "name": "ExcludeRobotic",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject robotic units.",
           "guard": "SetExcludeRobotic"
         },
         {
           "name": "ExcludeOrganic",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject organic units.",
           "guard": "SetExcludeOrganic"
         },
         {
           "name": "ExcludeCivilian",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units whose character template is civilian, whatever their team.",
           "guard": "SetExcludeCivilian"
         },
         {
           "name": "ExcludeNonCivilian",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units whose character template is not civilian, whatever their team.",
           "guard": "SetExcludeNonCivilian"
         },
         {
           "name": "ExcludeCosmetic",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject cosmetic units, such as Gremlins.",
           "guard": "SetExcludeCosmetic"
         },
         {
           "name": "ExcludeImpaired",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject impaired units.",
           "guard": "SetExcludeImpaired"
         },
         {
           "name": "ExcludePanicked",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject panicked units.",
           "guard": "SetExcludePanicked"
         },
         {
           "name": "ExcludeInStasis",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units in stasis.",
           "guard": "SetExcludeInStasis"
         },
         {
           "name": "ExcludeTurret",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject turrets.",
           "guard": "SetExcludeTurret"
         },
         {
           "name": "ExcludePsionic",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject psionic units.",
           "guard": "SetExcludePsionic"
         },
         {
           "name": "ExcludeNonPsionic",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject non-psionic units.",
           "guard": "SetExcludeNonPsionic"
         },
         {
           "name": "IsAdvent",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require an ADVENT unit.",
           "guard": "SetIsAdvent"
         },
         {
           "name": "ExcludeAdvent",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject ADVENT units.",
           "guard": "SetExcludeAdvent"
         },
         {
           "name": "ExcludeNoCover",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units that are not in cover.",
           "guard": "SetExcludeNoCover"
         },
         {
           "name": "ExcludeNoCoverToSource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units with no cover between them and the source.",
           "guard": "SetExcludeNoCoverToSource"
         },
         {
           "name": "ExcludeFullHealth",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units at full HP, unless a persistent damage effect listed in MedikitHealEffectTypes is on them.",
           "guard": "SetExcludeFullHealth"
         },
         {
           "name": "IsBleedingOut",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit that is bleeding out.",
           "guard": "SetIsBleedingOut"
         },
         {
           "name": "IsUnspotted",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit that has not been spotted.",
           "guard": "SetIsUnspotted"
         },
         {
           "name": "CanBeCarried",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit that can be carried.",
           "guard": "SetCanBeCarried"
         },
         {
           "name": "IsOutdoors",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit standing outdoors.",
           "guard": "SetIsOutdoors"
         },
         {
           "name": "IsConcealed",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a concealed unit.",
           "guard": "SetIsConcealed"
         },
         {
           "name": "ExcludeConcealed",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject concealed units. Only applies to the check without a source; visibility rules normally cover this.",
           "guard": "SetExcludeConcealed"
         },
         {
           "name": "IsSuperConcealed",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit in super concealment.",
           "guard": "SetIsSuperConcealed"
         },
         {
           "name": "IsImpaired",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require an impaired unit.",
           "guard": "SetIsImpaired"
         },
         {
           "name": "HasClearanceToMaxZ",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require open space above the unit up to the map ceiling.",
           "guard": "SetHasClearanceToMaxZ"
         },
         {
           "name": "ExcludeAlien",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject alien units.",
           "guard": "SetExcludeAlien"
         },
         {
           "name": "ExcludeNonHumanoidAliens",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject aliens that are not humanoid.",
           "guard": "SetExcludeNonHumanoidAliens"
         },
         {
           "name": "ExcludeStunned",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject stunned units.",
           "guard": "SetExcludeStunned"
         },
         {
           "name": "ExcludeDazed",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject dazed units.",
           "guard": "SetExcludeDazed"
         },
         {
           "name": "ExcludeUnableToAct",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units that are unable to act.",
           "guard": "SetExcludeUnableToAct"
         },
         {
           "name": "IsPlayerControlled",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a player-controlled unit.",
           "guard": "SetIsPlayerControlled"
         },
         {
           "name": "ExcludeUnrevealedAI",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject AI units that have not been revealed yet.",
           "guard": "SetExcludeUnrevealedAI"
         },
         {
           "name": "IncludeWeakAgainstTechLikeRobot",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Treat units flagged as weak against tech as robotic for the robotic checks.",
           "guard": "SetIncludeWeakAgainstTechLikeRobot"
         },
         {
           "name": "ImpairedIgnoresStuns",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Do not count stuns when deciding whether a unit is impaired.",
           "guard": "SetImpairedIgnoresStuns"
         },
         {
           "name": "IsScampering",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit that is currently scampering.",
           "guard": "SetIsScampering"
         },
         {
           "name": "ExcludeDeadFromSpecialDeath",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units killed by a special death.",
           "guard": "SetExcludeDeadFromSpecialDeath"
         },
         {
           "name": "ExcludeLargeUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units larger than one tile.",
           "guard": "SetExcludeLargeUnits"
         },
         {
           "name": "ImpairedIgnoresImpairingMomentarily",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Do not count momentary impairment when deciding whether a unit is impaired.",
           "guard": "SetImpairedIgnoresImpairingMomentarily"
         },
         {
           "name": "MinRank",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lowest soldier rank allowed.",
           "guard": "SetMinRank"
         },
         {
           "name": "MaxRank",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Highest soldier rank allowed.",
           "guard": "SetMaxRank"
         },
         {
@@ -994,7 +1008,7 @@
           "name": "ExcludeSoldierClasses",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Soldier classes that reject the unit. Non-soldiers always pass.",
           "modeField": "ExcludeSoldierClassesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1008,7 +1022,7 @@
           "name": "RequireSoldierClasses",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Soldier classes the unit must be one of, when non-empty. Non-soldiers always fail.",
           "modeField": "RequireSoldierClassesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1016,84 +1030,84 @@
           "name": "ExcludeHostileToSource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units hostile to the source.",
           "guard": "SetExcludeHostileToSource"
         },
         {
           "name": "ExcludeFriendlyToSource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units friendly to the source.",
           "guard": "SetExcludeFriendlyToSource"
         },
         {
           "name": "TreatMindControlledSquadmateAsHostile",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Count a mind-controlled squadmate as hostile rather than friendly.",
           "guard": "SetTreatMindControlledSquadmateAsHostile"
         },
         {
           "name": "ExcludeSquadmates",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reject units on the same team as the source.",
           "guard": "SetExcludeSquadmates"
         },
         {
           "name": "RequireSquadmates",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the unit to be on the same team as the source.",
           "guard": "SetRequireSquadmates"
         },
         {
           "name": "RequireWithinRange",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the unit to be within WithinRange of the source.",
           "guard": "SetRequireWithinRange"
         },
         {
           "name": "WithinRange",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Maximum distance between source and target, in Unreal units. A tile is 96.",
           "guard": "SetWithinRange"
         },
         {
           "name": "RequireWithinMinRange",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the unit to be within WithinMinRange of the source.",
           "guard": "SetRequireWithinMinRange"
         },
         {
           "name": "WithinMinRange",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Distance for the minimum-range check, in Unreal units. A tile is 96.",
           "guard": "SetWithinMinRange"
         },
         {
           "name": "BeingCarriedBySource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit currently carried by the source.",
           "guard": "SetBeingCarriedBySource"
         },
         {
           "name": "RequireUnitSelectedFromHQ",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a unit that was selected from Headquarters for the mission. XCOM only.",
           "guard": "SetRequireUnitSelectedFromHQ"
         },
         {
           "name": "FailOnNonUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail with AA_NotAUnit on non-unit targets instead of passing them through.",
           "guard": "SetFailOnNonUnits"
         },
         {
@@ -1106,7 +1120,7 @@
           "name": "CheckStats",
           "type": "array<CheckStat>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Stat checks that must all pass: the stat, the value check, and whether to compare as a percentage of the stat's maximum.",
           "modeField": "CheckStatsMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1120,7 +1134,7 @@
           "name": "IncludeTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Character groups the unit must belong to, when non-empty. Takes precedence over ExcludeTypes.",
           "modeField": "IncludeTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1134,7 +1148,7 @@
           "name": "ExcludeTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Character groups that reject the unit. Ignored while IncludeTypes is non-empty.",
           "modeField": "ExcludeTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1148,7 +1162,7 @@
           "name": "CheckValues",
           "type": "array<CheckValue>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Unit value checks that must all pass: the value name, the value check, and an optional failure code to return instead of the default.",
           "modeField": "CheckValuesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1156,91 +1170,91 @@
           "name": "NoEnemyViewers",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail when any enemy can see the target.",
           "guard": "SetNoEnemyViewers"
         },
         {
           "name": "RequireMatchCoverType",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the target to be in the cover type given by TargetCover.",
           "guard": "SetRequireMatchCoverType"
         },
         {
           "name": "RequireNotMatchCoverType",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the target not to be in the cover type given by TargetCover.",
           "guard": "SetRequireNotMatchCoverType"
         },
         {
           "name": "TargetCover",
           "type": "ECoverType",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cover type used by RequireMatchCoverType and RequireNotMatchCoverType.",
           "guard": "SetTargetCover"
         },
         {
           "name": "CannotPeek",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the shooter to see the target from its own tile, without peeking.",
           "guard": "SetCannotPeek"
         },
         {
           "name": "RequireLOS",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require line of sight.",
           "guard": "SetRequireLOS"
         },
         {
           "name": "RequireBasicVisibility",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require line of sight and range.",
           "guard": "SetRequireBasicVisibility"
         },
         {
           "name": "RequireGameplayVisible",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require line of sight, range and the situational gameplay-visibility rules.",
           "guard": "SetRequireGameplayVisible"
         },
         {
           "name": "AllowSquadsight",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Accept any squadmate's view of the target if the unit has Squadsight. Overrides RequireGameplayVisible.",
           "guard": "SetAllowSquadsight"
         },
         {
           "name": "ActAsSquadsight",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Accept any squadmate's view of the target whether or not the unit has Squadsight. Overrides RequireGameplayVisible.",
           "guard": "SetActAsSquadsight"
         },
         {
           "name": "VisibleToAnyAlly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Accept the target when any squadmate can see it, without line of sight from the unit itself. Overrides RequireGameplayVisible.",
           "guard": "SetVisibleToAnyAlly"
         },
         {
           "name": "DisablePeeksOnMovement",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Forbid peeking once the target has moved.",
           "guard": "SetDisablePeeksOnMovement"
         },
         {
           "name": "ExcludeGameplayVisible",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail when the target has gameplay visibility of the source.",
           "guard": "SetExcludeGameplayVisible"
         },
         {
@@ -1253,7 +1267,7 @@
           "name": "RequireGameplayVisibleTags",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Visibility tags that must be present on the visibility info, such as concealed or stealthed.",
           "modeField": "RequireGameplayVisibleTagsMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1261,161 +1275,161 @@
           "name": "MissionAborted",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the mission to have been aborted.",
           "guard": "SetMissionAborted"
         },
         {
           "name": "MissionNotAborted",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the mission not to have been aborted.",
           "guard": "SetMissionNotAborted"
         },
         {
           "name": "CiviliansTargetedByAliens",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a mission where aliens target civilians.",
           "guard": "SetCiviliansTargetedByAliens"
         },
         {
           "name": "CiviliansNotTargetedByAliens",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a mission where aliens do not target civilians.",
           "guard": "SetCiviliansNotTargetedByAliens"
         },
         {
           "name": "IncludeTheLostInEngagedCount",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Count the Lost among the engaged enemies.",
           "guard": "SetIncludeTheLostInEngagedCount"
         },
         {
           "name": "MinEngagedEnemies",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fewest engaged enemies required. -1 ignores it.",
           "guard": "SetMinEngagedEnemies"
         },
         {
           "name": "MaxEngagedEnemies",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Most engaged enemies allowed. -1 ignores it.",
           "guard": "SetMaxEngagedEnemies"
         },
         {
           "name": "FailOnNonUnitTargets",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail with AA_NotAUnit on non-unit targets instead of passing them through.",
           "guard": "SetFailOnNonUnitTargets"
         },
         {
           "name": "MinBondLevel",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lowest bond level between the two units, inclusive.",
           "guard": "SetMinBondLevel"
         },
         {
           "name": "MaxBondLevel",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Highest bond level between the two units, inclusive.",
           "guard": "SetMaxBondLevel"
         },
         {
           "name": "RequiresAdjacency",
           "type": "AdjacencyRequirement",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the bondmates may, must not, or must be adjacent: EAR_AnyAdjacency, EAR_DisallowAdjacency or EAR_RequireAdjacency.",
           "guard": "SetRequiresAdjacency"
         },
         {
           "name": "SkipCheckWithSource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only check that the source has a bondmate on the mission, not that the target is that bondmate. For self-targeted bondmate abilities.",
           "guard": "SetSkipCheckWithSource"
         },
         {
           "name": "IntrusionProtocol",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Hack objects at range: needs gameplay visibility of the object instead of an adjacent interaction point.",
           "guard": "SetIntrusionProtocol"
         },
         {
           "name": "HaywireProtocol",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Target units instead of objects: living, unhacked, robotic enemies the unit sees or has squadsight on.",
           "guard": "SetHaywireProtocol"
         },
         {
           "name": "RequiredAbilityName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ability the interactive object must expose. For hacking, empty accepts any object; for a normal interaction it must match exactly.",
           "guard": "SetRequiredAbilityName"
         },
         {
           "name": "MustBeDoor",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the object to be a door.",
           "guard": "SetMustBeDoor"
         },
         {
           "name": "RestrictRange",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require the loot to be within LootableRange of the source.",
           "guard": "SetRestrictRange"
         },
         {
           "name": "LootableRange",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Maximum distance to the loot, in Unreal units, when RestrictRange is set. A tile is 96.",
           "guard": "SetLootableRange"
         },
         {
           "name": "NotAFloorTileTag",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Tag of tiles that must not count as ground.",
           "guard": "SetNotAFloorTileTag"
         },
         {
           "name": "MaxPanicUnitsPerPod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Most units of an AI pod that may be panicked at once. 0 removes the limit.",
           "guard": "SetMaxPanicUnitsPerPod"
         },
         {
           "name": "HackAbilityName",
           "type": "Name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Hack ability whose rewards the target must offer, e.g. FinalizeSKULLJACK.",
           "guard": "SetHackAbilityName"
         },
         {
           "name": "CheckFlanking",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fail when any enemy flanks the unit.",
           "guard": "SetCheckFlanking"
         },
         {
           "name": "RequireVisible",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Require a free neighbouring tile the unit could be pulled to, rather than any free neighbouring tile.",
           "guard": "SetRequireVisible"
         },
         {
@@ -1428,7 +1442,7 @@
           "name": "AllowedBiomes",
           "type": "array<string>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Map biomes the mission must be in, when non-empty.",
           "modeField": "AllowedBiomesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1562,102 +1576,120 @@
           "kind": "plain",
           "description": "Per-entry edit mode (`EArrayEditMode`). Defaults to the enum's first value, which clears the existing array."
         },
+        {
+          "name": "ApplyOnTickClass",
+          "type": "string",
+          "kind": "plain",
+          "description": "Redirects this entry at an effect nested in the parent's `ApplyOnTick` list, so every other field below applies to that child instead. Only `X2Effect_Persistent` and its subclasses have one. Use it to reach the damage of a damage-over-time effect: the `X2Effect_Burning` object itself only carries duration, while the per-tick damage lives in an `X2Effect_ApplyWeaponDamage` beneath it. Bare names are auto-prefixed with `XComGame.`."
+        },
+        {
+          "name": "ApplyOnTickIndex",
+          "type": "int",
+          "kind": "plain",
+          "description": "Which matching child to edit when several in `ApplyOnTick` share the same class. Counts only matches of `ApplyOnTickClass`, so 0 is the first one. Default 0."
+        },
+        {
+          "name": "ApplyOnTickMode",
+          "type": "EArrayEditMode",
+          "kind": "plain",
+          "description": "What to do when `ApplyOnTickClass` is not already in the list (`EArrayEditMode`): `eAEM_Merge`/`eAEM_AddOnly` append one, `eAEM_Remove` removes it, `eAEM_ReplaceAll` clears the list first. Ignored when `ApplyOnTickClass` is empty."
+        },
         {
           "name": "ApplyOnHit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
           "guard": "SetApplyOnHit"
         },
         {
           "name": "ApplyOnMiss",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the effect is applied even when the ability misses.",
           "guard": "SetApplyOnMiss"
         },
         {
           "name": "ApplyChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
           "guard": "SetApplyChance"
         },
         {
           "name": "ApplyToWorldOnHit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
           "guard": "SetApplyToWorldOnHit"
         },
         {
           "name": "ApplyToWorldOnMiss",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
           "guard": "SetApplyToWorldOnMiss"
         },
         {
           "name": "UseSourcePlayerState",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
           "guard": "SetUseSourcePlayerState"
         },
         {
           "name": "IsImpairing",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
           "guard": "SetIsImpairing"
         },
         {
           "name": "IsImpairingMomentarily",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
           "guard": "SetIsImpairingMomentarily"
         },
         {
           "name": "BringRemoveVisualizationForward",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
           "guard": "SetBringRemoveVisualizationForward"
         },
         {
           "name": "ShowImmunity",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
           "guard": "SetShowImmunity"
         },
         {
           "name": "ShowImmunityAnyFailure",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
           "guard": "SetShowImmunityAnyFailure"
         },
         {
           "name": "AppliesDamage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
           "guard": "SetAppliesDamage"
         },
         {
           "name": "CanBeRedirected",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
           "guard": "SetCanBeRedirected"
         },
         {
           "name": "HideDeathWorldMessage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
           "guard": "SetHideDeathWorldMessage"
         },
         {
@@ -1670,7 +1702,7 @@
           "name": "DamageTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
           "modeField": "DamageTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -1684,385 +1716,385 @@
           "name": "MinStatContestResult",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
           "guard": "SetMinStatContestResult"
         },
         {
           "name": "MaxStatContestResult",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
           "guard": "SetMaxStatContestResult"
         },
         {
           "name": "DelayVisualizationSec",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
           "guard": "SetDelayVisualizationSec"
         },
         {
           "name": "OverrideMissMessage",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
           "guard": "SetOverrideMissMessage"
         },
         {
           "name": "NumTurns",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
           "guard": "SetNumTurns"
         },
         {
           "name": "InitialShedChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
           "guard": "SetInitialShedChance"
         },
         {
           "name": "PerTurnShedChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
           "guard": "SetPerTurnShedChance"
         },
         {
           "name": "EffectRank",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
           "guard": "SetEffectRank"
         },
         {
           "name": "EffectHierarchyValue",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
           "guard": "SetEffectHierarchyValue"
         },
         {
           "name": "VisionArcDegreesOverride",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
           "guard": "SetVisionArcDegreesOverride"
         },
         {
           "name": "InfiniteDuration",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
           "guard": "SetInfiniteDuration"
         },
         {
           "name": "TickWhenApplied",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
           "guard": "SetTickWhenApplied"
         },
         {
           "name": "CanTickEveryAction",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
           "guard": "SetCanTickEveryAction"
         },
         {
           "name": "ConvertTurnsToActions",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
           "guard": "SetConvertTurnsToActions"
         },
         {
           "name": "RemoveWhenSourceDies",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
           "guard": "SetRemoveWhenSourceDies"
         },
         {
           "name": "RemoveWhenTargetDies",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
           "guard": "SetRemoveWhenTargetDies"
         },
         {
           "name": "RemoveWhenSourceDamaged",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
           "guard": "SetRemoveWhenSourceDamaged"
         },
         {
           "name": "RemoveWhenTargetConcealmentBroken",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
           "guard": "SetRemoveWhenTargetConcealmentBroken"
         },
         {
           "name": "PersistThroughTacticalGameEnd",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
           "guard": "SetPersistThroughTacticalGameEnd"
         },
         {
           "name": "IgnorePlayerCheckOnTick",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
           "guard": "SetIgnorePlayerCheckOnTick"
         },
         {
           "name": "UniqueTarget",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
           "guard": "SetUniqueTarget"
         },
         {
           "name": "StackOnRefresh",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
           "guard": "SetStackOnRefresh"
         },
         {
           "name": "DupeForSameSourceOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
           "guard": "SetDupeForSameSourceOnly"
         },
         {
           "name": "EffectForcesBleedout",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
           "guard": "SetEffectForcesBleedout"
         },
         {
           "name": "DisplayInUI",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
           "guard": "SetDisplayInUI"
         },
         {
           "name": "DisplayInSpecialDamageMessageUI",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
           "guard": "SetDisplayInSpecialDamageMessageUI"
         },
         {
           "name": "SourceDisplayInUI",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
           "guard": "SetSourceDisplayInUI"
         },
         {
           "name": "CustomIdleOverrideAnim",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
           "guard": "SetCustomIdleOverrideAnim"
         },
         {
           "name": "EffectName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
           "guard": "SetEffectName"
         },
         {
           "name": "AbilitySourceName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
           "guard": "SetAbilitySourceName"
         },
         {
           "name": "EffectAppliedEventName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
           "guard": "SetEffectAppliedEventName"
         },
         {
           "name": "ChanceEventTriggerName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Event fired when the per-turn shed-chance roll succeeds.",
           "guard": "SetChanceEventTriggerName"
         },
         {
           "name": "VFXSocket",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Socket on the unit’s skeleton to attach the particle system to.",
           "guard": "SetVFXSocket"
         },
         {
           "name": "VFXSocketsArrayName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
           "guard": "SetVFXSocketsArrayName"
         },
         {
           "name": "FriendlyName",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Name shown in the unit’s status UI.",
           "guard": "SetFriendlyName"
         },
         {
           "name": "FriendlyDescription",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Description shown beneath FriendlyName in the status UI.",
           "guard": "SetFriendlyDescription"
         },
         {
           "name": "IconImage",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Path to the status icon shown in the UI.",
           "guard": "SetIconImage"
         },
         {
           "name": "SourceFriendlyName",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
           "guard": "SetSourceFriendlyName"
         },
         {
           "name": "SourceFriendlyDescription",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Description shown on the applying unit.",
           "guard": "SetSourceFriendlyDescription"
         },
         {
           "name": "SourceIconLabel",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Short label drawn on the applying unit’s icon.",
           "guard": "SetSourceIconLabel"
         },
         {
           "name": "StatusIcon",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
           "guard": "SetStatusIcon"
         },
         {
           "name": "VFXTemplateName",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Particle system played on the unit for as long as the effect lasts.",
           "guard": "SetVFXTemplateName"
         },
         {
           "name": "PersistentPerkName",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Perk effect played on the unit while this effect is active.",
           "guard": "SetPersistentPerkName"
         },
         {
           "name": "ExplosiveDamage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Counts the damage as explosive, so explosive-specific rules such as Blast Padding apply.",
           "guard": "SetExplosiveDamage"
         },
         {
           "name": "IgnoreBaseDamage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Leave out the weapon's base damage; only the effect's own damage and tagged extra damage apply.",
           "guard": "SetIgnoreBaseDamage"
         },
         {
           "name": "DamageTag",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Tag selecting one of the weapon's ExtraDamage entries and the upgrade bonus damage with the same tag.",
           "guard": "SetDamageTag"
         },
         {
           "name": "AlwaysKillsCivilians",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Civilian targets die outright regardless of the damage rolled.",
           "guard": "SetAlwaysKillsCivilians"
         },
         {
           "name": "ApplyWorldEffectsForEachTargetLocation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply the ability's world effects at every target location instead of once.",
           "guard": "SetApplyWorldEffectsForEachTargetLocation"
         },
         {
           "name": "AllowFreeKill",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Let free-kill weapon upgrades, such as the Repeater, trigger on this damage.",
           "guard": "SetAllowFreeKill"
         },
         {
           "name": "AllowWeaponUpgrade",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Let weapon upgrades add their bonus damage.",
           "guard": "SetAllowWeaponUpgrade"
         },
         {
           "name": "BypassShields",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage ignores shield HP and goes straight to health.",
           "guard": "SetBypassShields"
         },
         {
           "name": "IgnoreArmor",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage ignores armor.",
           "guard": "SetIgnoreArmor"
         },
         {
           "name": "BypassSustainEffects",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage ignores sustain effects that would otherwise keep the unit alive.",
           "guard": "SetBypassSustainEffects"
         },
         {
           "name": "EnvironmentalDamageAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Environmental damage dealt to terrain and cover.",
           "guard": "SetEnvironmentalDamageAmount"
         },
         {
           "name": "WeaponDamageValue",
           "type": "WeaponDamageValueEdit",
           "kind": "nested",
-          "description": ""
+          "description": "Damage the effect adds on its own, on top of the weapon: Damage, Spread, Crit, Pierce, Shred, Rupture, PlusOne, DamageType and Tag."
         },
         {
           "name": "StatChangeMode",
@@ -2074,7 +2106,7 @@
           "name": "StatChange",
           "type": "array<StatChangeEdit>",
           "kind": "nested",
-          "description": "",
+          "description": "Stat changes applied while the effect lasts, merged by StatType.",
           "modeField": "StatChangeMode",
           "modeEnum": "EStatChangeMode"
         },
@@ -2082,21 +2114,21 @@
           "name": "CHLForceReapplyOnRefresh",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
           "guard": "SetCHLForceReapplyOnRefresh"
         },
         {
           "name": "ImmuneTypesAreInclusive",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "true: immune to the listed damage types only. false: immune to every damage type except the listed ones.",
           "guard": "SetImmuneTypesAreInclusive"
         },
         {
           "name": "RemoveAfterAttackCount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Remove the effect after this many attacks against the unit. 0 keeps it.",
           "guard": "SetRemoveAfterAttackCount"
         },
         {
@@ -2109,7 +2141,7 @@
           "name": "ImmuneTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Damage types the immunity covers, or excludes when ImmuneTypesAreInclusive is false.",
           "modeField": "ImmuneTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2117,28 +2149,28 @@
           "name": "NumActionPoints",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Action points granted.",
           "guard": "SetNumActionPoints"
         },
         {
           "name": "PointType",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Type of action point granted, e.g. standard or move.",
           "guard": "SetPointType"
         },
         {
           "name": "ApplyOnlyWhenOut",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Grant only when the unit has no standard action points left.",
           "guard": "SetApplyOnlyWhenOut"
         },
         {
           "name": "SelectUnit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Select the unit in the tactical UI once the points are granted.",
           "guard": "SetSelectUnit"
         },
         {
@@ -2151,10 +2183,24 @@
           "name": "SkipWithEffect",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effects that, when present on the unit, skip the grant.",
           "modeField": "SkipWithEffectMode",
           "modeEnum": "ENameArrayEditMode"
         },
+        {
+          "name": "RecordUnitValueWithGrantMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Effect_GrantActionPointsWithRecord (merged by UnitValueName)"
+        },
+        {
+          "name": "RecordUnitValueWithGrant",
+          "type": "array<RecordData>",
+          "kind": "modedArray",
+          "description": "Unit values that accumulate the action points granted, each with its cleanup rule. Merge updates the entry with the same UnitValueName or adds it.",
+          "modeField": "RecordUnitValueWithGrantMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "EffectNamesToRemoveMode",
           "type": "ENameArrayEditMode",
@@ -2165,7 +2211,7 @@
           "name": "EffectNamesToRemove",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effect names removed from the target.",
           "modeField": "EffectNamesToRemoveMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2173,98 +2219,98 @@
           "name": "Cleanse",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Remove the effects as a cleanse, so whatever they do on wearing off does not trigger.",
           "guard": "SetCleanse"
         },
         {
           "name": "CheckSource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Match effects whose source is this effect's target, instead of effects whose target it is.",
           "guard": "SetCheckSource"
         },
         {
           "name": "DoNotVisualize",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Skip the removal visualization, for when another RemoveEffects on the ability already shows it.",
           "guard": "SetDoNotVisualize"
         },
         {
           "name": "UnitName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value written.",
           "guard": "SetUnitName"
         },
         {
           "name": "NewValueToSet",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Value written to the unit value.",
           "guard": "SetNewValueToSet"
         },
         {
           "name": "CleanupType",
           "type": "EUnitValueCleanup",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "When the unit value is cleared: eCleanup_BeginTurn, eCleanup_BeginTactical, eCleanup_Never or eCleanup_BeginTacticalChain.",
           "guard": "SetCleanupType"
         },
         {
           "name": "ArmorMitigationAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Armor points granted while the effect lasts.",
           "guard": "SetArmorMitigationAmount"
         },
         {
           "name": "StunLevel",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Action points the stun takes away.",
           "guard": "SetStunLevel"
         },
         {
           "name": "SkipAnimation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Skip the stun animations.",
           "guard": "SetSkipAnimation"
         },
         {
           "name": "StunStartAnimName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played when the stun starts, if the unit can play it.",
           "guard": "SetStunStartAnimName"
         },
         {
           "name": "StunStopAnimName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played when the stun ends.",
           "guard": "SetStunStopAnimName"
         },
         {
           "name": "StunnedTriggerName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Event fired when the unit is stunned.",
           "guard": "SetStunnedTriggerName"
         },
         {
           "name": "SustainedAbilityName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ability on the source that is fired again once a full turn completes, to keep the effect going.",
           "guard": "SetSustainedAbilityName"
         },
         {
           "name": "FragileAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage the source may take in a full turn before the effect breaks. 0 never breaks it.",
           "guard": "SetFragileAmount"
         },
         {
@@ -2277,7 +2323,7 @@
           "name": "EffectsToRemoveFromSource",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effects removed from the source when this effect ends.",
           "modeField": "EffectsToRemoveFromSourceMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2291,7 +2337,7 @@
           "name": "EffectsToRemoveFromTarget",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effects removed from the target when this effect ends.",
           "modeField": "EffectsToRemoveFromTargetMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2305,7 +2351,7 @@
           "name": "RegisterAdditionalEventsLikeImpair",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Extra events on the source that end the effect as if the source had become impaired.",
           "modeField": "RegisterAdditionalEventsLikeImpairMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2313,112 +2359,112 @@
           "name": "ReasonNotVisible",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Visibility tag given as the reason the vanished unit cannot be seen.",
           "guard": "SetReasonNotVisible"
         },
         {
           "name": "VanishRevealAdditiveAnimName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Additive animation played on reveal when VanishRevealAnimName is empty.",
           "guard": "SetVanishRevealAdditiveAnimName"
         },
         {
           "name": "VanishRevealAnimName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played when the unit is revealed.",
           "guard": "SetVanishRevealAnimName"
         },
         {
           "name": "VanishSyncAnimName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Additive animation played when the vanished state is visualized from a save.",
           "guard": "SetVanishSyncAnimName"
         },
         {
           "name": "ReserveType",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Type of action point reserved.",
           "guard": "SetReserveType"
         },
         {
           "name": "NumPoints",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Number of action points reserved.",
           "guard": "SetNumPoints"
         },
         {
           "name": "AbilityToActivate",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ability fired when the covering fire check matches.",
           "guard": "SetAbilityToActivate"
         },
         {
           "name": "GrantActionPoint",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reserve action point given to the covering unit when the check matches.",
           "guard": "SetGrantActionPoint"
         },
         {
           "name": "MaxPointsPerTurn",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Most times per turn the action point can be granted. 0 or less removes the limit.",
           "guard": "SetMaxPointsPerTurn"
         },
         {
           "name": "DirectAttackOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only match when the unit carrying the effect is attacked directly.",
           "guard": "SetDirectAttackOnly"
         },
         {
           "name": "PreEmptiveFire",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fire before the attacker's shot resolves instead of after it.",
           "guard": "SetPreEmptiveFire"
         },
         {
           "name": "OnlyDuringEnemyTurn",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only fire during the enemy turn.",
           "guard": "SetOnlyDuringEnemyTurn"
         },
         {
           "name": "UseMultiTargets",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fire the ability at the covering unit itself and hit its multi-targets, instead of retaliating at the attacker.",
           "guard": "SetUseMultiTargets"
         },
         {
           "name": "OnlyWhenAttackMisses",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only fire when the attack missed.",
           "guard": "SetOnlyWhenAttackMisses"
         },
         {
           "name": "SelfTargeting",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "The fired ability targets the covering unit itself.",
           "guard": "SetSelfTargeting"
         },
         {
           "name": "ActivationPercentChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percent chance the ability fires when the check matches. 0 always fires.",
           "guard": "SetActivationPercentChance"
         },
         {
@@ -2431,7 +2477,7 @@
           "name": "TraversalChanges",
           "type": "array<TraversalChange>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Traversal types switched on or off while the effect lasts, merged by Traversal.",
           "modeField": "TraversalChangesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2439,14 +2485,14 @@
           "name": "ToHitMin",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lowest hit chance at which the damage multiplier applies.",
           "guard": "SetToHitMin"
         },
         {
           "name": "DmgMod",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Multiplier applied to the damage when the effect's condition is met.",
           "guard": "SetDmgMod"
         },
         {
@@ -2459,169 +2505,267 @@
           "name": "AdverseClasses",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Soldier classes whose attacks trigger the damage multiplier.",
           "modeField": "AdverseClassesMode",
           "modeEnum": "ENameArrayEditMode"
         },
+        {
+          "name": "AlertRangeMeters",
+          "type": "int",
+          "kind": "optionalScalar",
+          "description": "Radius in meters within which Lost are alerted.",
+          "guard": "SetAlertRangeMeters"
+        },
         {
           "name": "BonusDamageMult",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fraction of the damage added as bonus.",
           "guard": "SetBonusDamageMult"
         },
         {
           "name": "MinBonusDamage",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Smallest bonus damage applied, when the fraction comes out lower.",
           "guard": "SetMinBonusDamage"
         },
         {
-          "name": "OverrideParticleSystemFill_Name",
+          "name": "AcidParticleSystem1Tile",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetOverrideParticleSystemFill_Name"
+          "description": "Particle system path for an acid pool covering a single tile.",
+          "guard": "SetAcidParticleSystem1Tile"
+        },
+        {
+          "name": "AcidParticleSystem2Tiles",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering two tiles.",
+          "guard": "SetAcidParticleSystem2Tiles"
+        },
+        {
+          "name": "AcidParticleSystem3TilesLine",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering three tiles in a line.",
+          "guard": "SetAcidParticleSystem3TilesLine"
+        },
+        {
+          "name": "AcidParticleSystem3TilesCorner",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering three tiles in a corner.",
+          "guard": "SetAcidParticleSystem3TilesCorner"
+        },
+        {
+          "name": "AcidParticleSystem4TilesLine",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering four tiles in a line.",
+          "guard": "SetAcidParticleSystem4TilesLine"
+        },
+        {
+          "name": "AcidParticleSystem4TilesSquare",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering a 2x2 square.",
+          "guard": "SetAcidParticleSystem4TilesSquare"
+        },
+        {
+          "name": "AcidParticleSystem4TilesL",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering four tiles in an L shape.",
+          "guard": "SetAcidParticleSystem4TilesL"
+        },
+        {
+          "name": "AcidParticleSystem4TilesReverseL",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering four tiles in a mirrored L shape.",
+          "guard": "SetAcidParticleSystem4TilesReverseL"
+        },
+        {
+          "name": "AcidParticleSystem4TilesT",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering four tiles in a T shape (the game's 4pc_Middle).",
+          "guard": "SetAcidParticleSystem4TilesT"
+        },
+        {
+          "name": "AcidParticleSystem4TilesS",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering four tiles in an S shape.",
+          "guard": "SetAcidParticleSystem4TilesS"
+        },
+        {
+          "name": "AcidParticleSystem4TilesReverseS",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for an acid pool covering four tiles in a mirrored S shape.",
+          "guard": "SetAcidParticleSystem4TilesReverseS"
+        },
+        {
+          "name": "OverrideParticleSystem",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path played on the target instead of the default one. Empty keeps the default.",
+          "guard": "SetOverrideParticleSystem"
         },
         {
           "name": "DamageTypeTemplateName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage type of the environmental damage.",
           "guard": "SetDamageTypeTemplateName"
         },
         {
           "name": "PlusNumZTiles",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Extra tiles of height hit above the affected tile.",
           "guard": "SetPlusNumZTiles"
         },
         {
           "name": "UseWeaponEnvironmentalDamage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Use the source weapon's environmental damage instead of EnvironmentalDamageAmount.",
           "guard": "SetUseWeaponEnvironmentalDamage"
         },
         {
           "name": "UseWeaponDamageType",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Use the source weapon's damage type instead of DamageTypeTemplateName.",
           "guard": "SetUseWeaponDamageType"
         },
         {
           "name": "HitSourceTile",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply the damage at the source's tile.",
           "guard": "SetHitSourceTile"
         },
         {
           "name": "HitTargetTile",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply the damage at the target's tile.",
           "guard": "SetHitTargetTile"
         },
         {
           "name": "HitAdjacentDestructibles",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Also damage destructibles adjacent to the hit tile along the damage direction.",
           "guard": "SetHitAdjacentDestructibles"
         },
         {
           "name": "AllowDestructionOfDamageCauseCover",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "When a unit caused the damage, allow it to destroy that unit's own cover, which is normally protected.",
           "guard": "SetAllowDestructionOfDamageCauseCover"
         },
         {
           "name": "FireChance_Level1",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Weight of a level 1 fire when rolling the intensity of new fires; relative to the other two levels.",
           "guard": "SetFireChance_Level1"
         },
         {
           "name": "FireChance_Level2",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Weight of a level 2 fire when rolling the intensity of new fires; relative to the other two levels.",
           "guard": "SetFireChance_Level2"
         },
         {
           "name": "FireChance_Level3",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Weight of a level 3 fire when rolling the intensity of new fires; relative to the other two levels.",
           "guard": "SetFireChance_Level3"
         },
         {
           "name": "UseFireChanceLevel",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Roll the fire intensity from the three FireChance weights instead of using the default.",
           "guard": "SetUseFireChanceLevel"
         },
         {
           "name": "DamageFragileOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only damage fragile objects.",
           "guard": "SetDamageFragileOnly"
         },
         {
           "name": "CheckForLOSFromTargetLocation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only set tiles on fire that are visible from the target location.",
           "guard": "SetCheckForLOSFromTargetLocation"
         },
         {
           "name": "PerUseHP",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "HP healed per application.",
           "guard": "SetPerUseHP"
         },
         {
           "name": "IncreasedHealProject",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Research that, once completed, switches the heal to IncreasedPerUseHP.",
           "guard": "SetIncreasedHealProject"
         },
         {
           "name": "IncreasedPerUseHP",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "HP healed per application once IncreasedHealProject is researched.",
           "guard": "SetIncreasedPerUseHP"
         },
+        {
+          "name": "PoisonParticleSystem",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for a poison cloud tile.",
+          "guard": "SetPoisonParticleSystem"
+        },
+        {
+          "name": "SmokeParticleSystem",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Particle system path for a smoke tile.",
+          "guard": "SetSmokeParticleSystem"
+        },
         {
           "name": "Pierce",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Armor pierced.",
           "guard": "SetPierce"
         },
         {
           "name": "CritChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Crit chance added.",
           "guard": "SetCritChance"
         },
         {
           "name": "CritDamage",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Crit damage added.",
           "guard": "SetCritDamage"
         },
         {
@@ -2634,7 +2778,7 @@
           "name": "EventsToUpdate",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Events that make the aura re-evaluate which units it covers.",
           "modeField": "EventsToUpdateMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2642,126 +2786,189 @@
           "name": "NumHitsForMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Hits taken in the turn before the damage multiplier applies.",
           "guard": "SetNumHitsForMod"
         },
         {
           "name": "ExplosiveDamageReduction",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fraction of explosive damage removed.",
           "guard": "SetExplosiveDamageReduction"
         },
         {
           "name": "BonusDamage",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Bonus damage added when the effect's condition is met.",
           "guard": "SetBonusDamage"
         },
+        {
+          "name": "ThreatenedBondmateAimBonus",
+          "type": "int",
+          "kind": "optionalScalar",
+          "description": "Aim bonus, from bond level 2, against a target that threatens the bondmate.",
+          "guard": "SetThreatenedBondmateAimBonus"
+        },
+        {
+          "name": "BondmateTargetAimBonus",
+          "type": "int",
+          "kind": "optionalScalar",
+          "description": "Aim bonus, from bond level 3, against a target the bondmate attacked since last turn.",
+          "guard": "SetBondmateTargetAimBonus"
+        },
+        {
+          "name": "BondmateTargetCritBonus",
+          "type": "int",
+          "kind": "optionalScalar",
+          "description": "Crit bonus, from bond level 3, against a target the bondmate attacked since last turn.",
+          "guard": "SetBondmateTargetCritBonus"
+        },
+        {
+          "name": "BleedoutDurationAdjustment",
+          "type": "int",
+          "kind": "optionalScalar",
+          "description": "Turns added to the bleedout duration.",
+          "guard": "SetBleedoutDurationAdjustment"
+        },
         {
           "name": "BonusDmg",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Bonus damage added to the weapon's damage.",
           "guard": "SetBonusDmg"
         },
         {
           "name": "WillMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Change applied to the target's current Will; negative lowers it.",
           "guard": "SetWillMod"
         },
+        {
+          "name": "DamageTypeImmunitiesMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Effect_CombatStims, X2Effect_Solace"
+        },
+        {
+          "name": "DamageTypeImmunities",
+          "type": "array<name>",
+          "kind": "modedArray",
+          "description": "Damage types the affected unit is immune to while the effect lasts.",
+          "modeField": "DamageTypeImmunitiesMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "ModifyOutgoingDamage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply to damage the unit deals.",
           "guard": "SetModifyOutgoingDamage"
         },
         {
           "name": "ModifyIncomingDamage",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply to damage the unit takes.",
           "guard": "SetModifyIncomingDamage"
         },
         {
           "name": "DamageModifier",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage multiplier; 1.0 leaves the damage unchanged.",
           "guard": "SetDamageModifier"
         },
         {
           "name": "DamageBonus",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Flat damage added after the multiplier.",
           "guard": "SetDamageBonus"
         },
+        {
+          "name": "DamageMultiplier",
+          "type": "float",
+          "kind": "optionalScalar",
+          "description": "Extra damage as a fraction of the damage being dealt.",
+          "guard": "SetDamageMultiplier"
+        },
         {
           "name": "TriggerEventName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Event the effect fires.",
           "guard": "SetTriggerEventName"
         },
         {
           "name": "GlobalAbility",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Global ability switched on for the rest of the battle.",
           "guard": "SetGlobalAbility"
         },
+        {
+          "name": "DamageImmunitiesMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Effect_Fortress"
+        },
+        {
+          "name": "DamageImmunities",
+          "type": "array<name>",
+          "kind": "modedArray",
+          "description": "Damage types the unit is immune to. The game assumes Fire, Acid and Poison are among them.",
+          "modeField": "DamageImmunitiesMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "CoverType",
           "type": "ECoverForceFlag",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cover the unit provides to others: none, low or high (ECoverForceFlag).",
           "guard": "SetCoverType"
         },
         {
           "name": "RemoveWhenMoved",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Remove the effect when the unit moves.",
           "guard": "SetRemoveWhenMoved"
         },
         {
           "name": "RemoveOnOtherActivation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Remove the effect when the unit activates another ability.",
           "guard": "SetRemoveOnOtherActivation"
         },
         {
           "name": "OverrideStartAnimName",
           "type": "Name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played on the pulled unit at the start, when set.",
           "guard": "SetOverrideStartAnimName"
         },
         {
           "name": "OverrideStopAnimName",
           "type": "Name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played on the pulled unit at the end, when set.",
           "guard": "SetOverrideStopAnimName"
         },
         {
           "name": "RequireVisibleTile",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only pull to a neighbouring tile the target can be bound to; otherwise any free neighbouring tile will do.",
           "guard": "SetRequireVisibleTile"
         },
         {
           "name": "HeightBonus",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Extra aim an attacker gets when it has height advantage over the affected unit.",
           "guard": "SetHeightBonus"
         },
         {
@@ -2774,7 +2981,7 @@
           "name": "AllowedAbilities",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Abilities that can trigger the extra reaction shot.",
           "modeField": "AllowedAbilitiesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -2782,322 +2989,329 @@
           "name": "ProcChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percent chance of the extra reaction shot.",
           "guard": "SetProcChance"
         },
         {
           "name": "HitMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Hit chance modifier applied.",
           "guard": "SetHitMod"
         },
         {
           "name": "DelayTimeS",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Seconds before the death is visualized.",
           "guard": "SetDelayTimeS"
         },
         {
           "name": "AbilityToTrigger",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ability fired when the mine goes off.",
           "guard": "SetAbilityToTrigger"
         },
         {
           "name": "BonusCritChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Crit chance added when the effect's condition is met.",
           "guard": "SetBonusCritChance"
         },
         {
           "name": "AbilityName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ability fired by the effect.",
           "guard": "SetAbilityName"
         },
         {
           "name": "ActivateAbilityOnTarget",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Find and fire the ability on the target instead of the source.",
           "guard": "SetActivateAbilityOnTarget"
         },
         {
           "name": "EffectTargetOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fire only against the effect's target; false fires against every available target.",
           "guard": "SetEffectTargetOnly"
         },
         {
           "name": "ImplacableThisTurnValue",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value that records Implacable already triggered this turn.",
           "guard": "SetImplacableThisTurnValue"
         },
         {
           "name": "CohesionAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cohesion added between the unit and its bondmate.",
           "guard": "SetCohesionAmount"
         },
         {
           "name": "ShieldPerMiss",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Shield HP gained each time an attack misses the unit.",
           "guard": "SetShieldPerMiss"
         },
         {
           "name": "KnockbackDistance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Distance the unit is knocked back, in meters.",
           "guard": "SetKnockbackDistance"
         },
         {
           "name": "KnockbackDestroysNonFragile",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Let the knocked-back unit destroy non-fragile objects it hits.",
           "guard": "SetKnockbackDestroysNonFragile"
         },
         {
           "name": "OverrideRagdollFinishTimerSec",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Seconds before the ragdoll settles. Negative keeps the default.",
           "guard": "SetOverrideRagdollFinishTimerSec"
         },
         {
           "name": "OnlyOnDeath",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only knock back units the attack kills.",
           "guard": "SetOnlyOnDeath"
         },
         {
           "name": "BenefitFromEmpoweredUpgrades",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Increase the crit bonus when XCOM has empowered weapon upgrades. Community Highlander field.",
           "guard": "SetBenefitFromEmpoweredUpgrades"
         },
         {
           "name": "CritBonus",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Crit chance added on top of the distance-based bonus.",
           "guard": "SetCritBonus"
         },
         {
           "name": "LifeAmountMultiplier",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Multiplier on the health stolen. 0 leaves the amount unchanged.",
           "guard": "SetLifeAmountMultiplier"
         },
         {
           "name": "AbilityToMark",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ability whose valid activation tiles are marked.",
           "guard": "SetAbilityToMark"
         },
         {
           "name": "OnlyUseTargetLocation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Mark only the target location, ignoring the ability's multi-target area.",
           "guard": "SetOnlyUseTargetLocation"
         },
         {
           "name": "VisualizeFlagsOnCursor",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Show the marked tiles on the targeting cursor.",
           "guard": "SetVisualizeFlagsOnCursor"
         },
         {
           "name": "DamageMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage added to attacks of the melee damage type.",
           "guard": "SetDamageMod"
         },
         {
           "name": "MeleeDamageTypeName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage type that counts as melee for the adjustment.",
           "guard": "SetMeleeDamageTypeName"
         },
+        {
+          "name": "AbilitiesAllowedToHitMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Effect_MimicBeacon"
+        },
+        {
+          "name": "AbilitiesAllowedToHit",
+          "type": "array<name>",
+          "kind": "modedArray",
+          "description": "Abilities that may still target the mimic beacon.",
+          "modeField": "AbilitiesAllowedToHitMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "NumTurnsForAI",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Turns the control lasts when an AI player is the controller. 0 uses the effect's normal duration.",
           "guard": "SetNumTurnsForAI"
         },
         {
           "name": "RemoveGroupFromInitiativeOrder",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Remove the unit's group from the initiative order.",
           "guard": "SetRemoveGroupFromInitiativeOrder"
         },
         {
           "name": "AddGroupToInitiativeOrder",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Add the unit's group to the initiative order.",
           "guard": "SetAddGroupToInitiativeOrder"
         },
         {
           "name": "AllowCrit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Allow reaction fire to crit.",
           "guard": "SetAllowCrit"
         },
         {
           "name": "ReactionModifier",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Aim modifier applied to reaction fire.",
           "guard": "SetReactionModifier"
         },
+        {
+          "name": "AdditionalSuccessModifiersMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Effect_ModifyStatCheckSuccesses (merged by AbilityName)"
+        },
+        {
+          "name": "AdditionalSuccessModifiers",
+          "type": "array<AdditionalSuccessModifier>",
+          "kind": "modedArray",
+          "description": "Bonus successes added to a stat check made by the named ability, when the checked unit is the ability's source. Merge updates the entry with the same AbilityName or adds it.",
+          "modeField": "AdditionalSuccessModifiersMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "ModifyFocus",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Focus points added; negative removes them.",
           "guard": "SetModifyFocus"
         },
         {
           "name": "ArmorPierce",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Armor pierced.",
           "guard": "SetArmorPierce"
         },
         {
           "name": "ObsessedTargetValueName",
           "type": "Name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value holding the object ID of the obsessed-over target.",
           "guard": "SetObsessedTargetValueName"
         },
+        {
+          "name": "DeathActionClass",
+          "type": "string",
+          "kind": "optionalScalar",
+          "description": "Qualified class path of the X2Action that replaces the normal death visualization, e.g. XComGame.X2Action_ExplodingUnitDeathAction. Empty removes the override.",
+          "guard": "SetDeathActionClass"
+        },
         {
           "name": "OverrideAnimNameOnLoad",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Death animation shown for the unit when a save is loaded.",
           "guard": "SetOverrideAnimNameOnLoad"
         },
         {
           "name": "CritBoostPerKill",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Crit chance gained per kill.",
           "guard": "SetCritBoostPerKill"
         },
         {
           "name": "MaxCritBoost",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Cap on the accumulated crit chance.",
           "guard": "SetMaxCritBoost"
         },
-        {
-          "name": "ParthenogenicPoisonType",
-          "type": "name",
-          "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetParthenogenicPoisonType"
-        },
-        {
-          "name": "ParthenogenicPoisonCocoonSpawnedName",
-          "type": "name",
-          "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetParthenogenicPoisonCocoonSpawnedName"
-        },
         {
           "name": "AltUnitToSpawnName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Character template spawned instead of the usual one, when set.",
           "guard": "SetAltUnitToSpawnName"
         },
         {
           "name": "UseWeaponRadius",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Use the source weapon's radius as the sight radius. Requires a source weapon.",
           "guard": "SetUseWeaponRadius"
         },
         {
           "name": "ViewRadius",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Sight radius of the viewer.",
           "guard": "SetViewRadius"
         },
         {
           "name": "UseSourceLocation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Place the viewer at the source's location rather than the target's.",
           "guard": "SetUseSourceLocation"
         },
         {
           "name": "InitialDamage",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage dealt when the effect is applied.",
           "guard": "SetInitialDamage"
         },
         {
           "name": "WeaponTemplateName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Item template equipped on the possessed unit.",
           "guard": "SetWeaponTemplateName"
         },
         {
-          "name": "ReaperActivatedName",
-          "type": "name",
+          "name": "Amount",
+          "type": "int",
           "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetReaperActivatedName"
-        },
-        {
-          "name": "ReaperKillName",
-          "type": "name",
-          "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetReaperKillName"
-        },
-        {
-          "name": "Amount",
-          "type": "int",
-          "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetAmount"
+          "description": "Turns taken off each cooldown.",
+          "guard": "SetAmount"
         },
         {
           "name": "ReduceAll",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Clear the cooldowns entirely instead of reducing them by Amount.",
           "guard": "SetReduceAll"
         },
         {
@@ -3110,7 +3324,7 @@
           "name": "AbilitiesToTick",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Abilities whose cooldowns are reduced. Empty means every ability.",
           "modeField": "AbilitiesToTickMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3118,42 +3332,42 @@
           "name": "HealAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "HP healed per tick.",
           "guard": "SetHealAmount"
         },
         {
           "name": "MaxHealAmount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Total HP the effect may heal, tracked in HealthRegeneratedName. 0 removes the cap.",
           "guard": "SetMaxHealAmount"
         },
         {
           "name": "HealthRegeneratedName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value that accumulates the HP healed so far, for the MaxHealAmount cap.",
           "guard": "SetHealthRegeneratedName"
         },
         {
           "name": "EventToTriggerOnHeal",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Event fired after each heal.",
           "guard": "SetEventToTriggerOnHeal"
         },
         {
           "name": "UnitDamageMultiplier",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Multiplier on the damage the detonated object deals to units.",
           "guard": "SetUnitDamageMultiplier"
         },
         {
           "name": "DamageRadiusMultiplier",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Multiplier on the detonation's damage radius.",
           "guard": "SetDamageRadiusMultiplier"
         },
         {
@@ -3166,7 +3380,7 @@
           "name": "DamageTypesToRemove",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Effects carrying any of these damage types are removed.",
           "modeField": "DamageTypesToRemoveMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3180,7 +3394,7 @@
           "name": "UseAllPointsWithAbilities",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Abilities that, when the unit has any of them, reserve as many points as were spent instead of NumPoints.",
           "modeField": "UseAllPointsWithAbilitiesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3188,203 +3402,196 @@
           "name": "NumActions",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Number of behavior tree actions the unit runs.",
           "guard": "SetNumActions"
         },
         {
           "name": "BehaviorTreeName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Behavior tree run on the unit.",
           "guard": "SetBehaviorTreeName"
         },
         {
           "name": "InitFromPlayer",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reset the behavior tree variables on each run as if the player turn were starting.",
           "guard": "SetInitFromPlayer"
         },
         {
           "name": "SetActionPointCount",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Standard action points given to the unit before the tree runs.",
           "guard": "SetSetActionPointCount"
         },
-        {
-          "name": "LookAtDuration",
-          "type": "float",
-          "kind": "optionalScalar",
-          "description": "",
-          "guard": "SetLookAtDuration"
-        },
         {
           "name": "ShatteredTargetValueName",
           "type": "Name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value holding the object ID of the unit that shattered the target.",
           "guard": "SetShatteredTargetValueName"
         },
         {
           "name": "UnitValueToRead",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value read to find how much health to steal.",
           "guard": "SetUnitValueToRead"
         },
         {
           "name": "DestructibleArchetype",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Archetype path of the destructible actor spawned.",
           "guard": "SetDestructibleArchetype"
         },
         {
           "name": "DestroyOnRemoval",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Destroy the spawned actor when the effect is removed.",
           "guard": "SetDestroyOnRemoval"
         },
         {
           "name": "TargetableBySpawnedTeamOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only the team that spawned the actor can target it.",
           "guard": "SetTargetableBySpawnedTeamOnly"
         },
         {
           "name": "AnimationName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reanimation animation played on the corpse.",
           "guard": "SetAnimationName"
         },
         {
           "name": "StartAnimationMinDelaySec",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Shortest delay, in seconds, before the reanimation animation starts.",
           "guard": "SetStartAnimationMinDelaySec"
         },
         {
           "name": "StartAnimationMaxDelaySec",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Longest delay, in seconds, before the reanimation animation starts.",
           "guard": "SetStartAnimationMaxDelaySec"
         },
         {
           "name": "ShadowbindUnconciousCheckName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Unit value checked to tell whether the shadowbound unit was unconscious.",
           "guard": "SetShadowbindUnconciousCheckName"
         },
         {
           "name": "UnitToSpawnName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Character template of the unit spawned.",
           "guard": "SetUnitToSpawnName"
         },
         {
           "name": "ClearTileBlockedByTargetUnitFlag",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Spawn on the target's own tile.",
           "guard": "SetClearTileBlockedByTargetUnitFlag"
         },
         {
           "name": "CopyTargetAppearance",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Give the spawned unit the target's appearance. Takes precedence over CopySourceAppearance.",
           "guard": "SetCopyTargetAppearance"
         },
         {
           "name": "CopySourceAppearance",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Give the spawned unit the source's appearance.",
           "guard": "SetCopySourceAppearance"
         },
         {
           "name": "KnockbackAffectsSpawnLocation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Spawn where the target ended up after knockback rather than where it was hit.",
           "guard": "SetKnockbackAffectsSpawnLocation"
         },
         {
           "name": "AddToSourceGroup",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Put the spawned unit in the source's AI group.",
           "guard": "SetAddToSourceGroup"
         },
         {
           "name": "CopyReanimatedFromUnit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Copy the reanimated unit's inventory and abilities too, not just its appearance.",
           "guard": "SetCopyReanimatedFromUnit"
         },
         {
           "name": "CopyReanimatedStatsFromUnit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Copy the reanimated unit's stats.",
           "guard": "SetCopyReanimatedStatsFromUnit"
         },
         {
           "name": "SetProcessedScamperAs",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Mark the spawned unit's group as having already scampered, so it does not reveal and scamper on sight.",
           "guard": "SetSetProcessedScamperAs"
         },
         {
           "name": "BecomeUnspotted",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Mark the unit as unspotted instead of spotted.",
           "guard": "SetBecomeUnspotted"
         },
         {
           "name": "StunStartAnim",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played when stasis starts.",
           "guard": "SetStunStartAnim"
         },
         {
           "name": "StunStopAnim",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Animation played when stasis ends.",
           "guard": "SetStunStopAnim"
         },
         {
           "name": "SkipFlyover",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Skip the flyover text.",
           "guard": "SetSkipFlyover"
         },
         {
           "name": "StartAnimBlendTime",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Blend time, in seconds, into the start animation.",
           "guard": "SetStartAnimBlendTime"
         },
         {
           "name": "ConcealAmountScalar",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Multiplier on the base chance of losing super concealment, added to the modifier.",
           "guard": "SetConcealAmountScalar"
         },
         {
@@ -3397,7 +3604,7 @@
           "name": "AbilitiesAffectedFilter",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Abilities the modifier applies to. Empty means every ability.",
           "modeField": "AbilitiesAffectedFilterMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3411,7 +3618,7 @@
           "name": "RemoveOnAbilityActivation",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Abilities whose activation removes the effect.",
           "modeField": "RemoveOnAbilityActivationMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3419,42 +3626,42 @@
           "name": "ResumeMissionTimer",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Resume the mission timer instead of suspending it.",
           "guard": "SetResumeMissionTimer"
         },
         {
           "name": "AimMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Aim added.",
           "guard": "SetAimMod"
         },
         {
           "name": "BonusDmgFloat",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Bonus damage: a flat amount with MODOP_Addition, or a multiplier on the damage with MODOP_Multiplication.",
           "guard": "SetBonusDmgFloat"
         },
         {
           "name": "BonusModType",
           "type": "EStatModOp",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "How BonusDmgFloat is applied: MODOP_Addition or MODOP_Multiplication.",
           "guard": "SetBonusModType"
         },
         {
           "name": "WithinTileDistance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Farthest distance to the target, in tiles, at which the bonus applies.",
           "guard": "SetWithinTileDistance"
         },
         {
           "name": "PrimaryTargetOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Only apply to the attack's primary target.",
           "guard": "SetPrimaryTargetOnly"
         },
         {
@@ -3467,7 +3674,7 @@
           "name": "BonusDamageTypes",
           "type": "array<name>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Damage types the bonus applies to.",
           "modeField": "BonusDamageTypesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3475,84 +3682,98 @@
           "name": "ImmediateActionPoint",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Reserve action point given to the target as soon as the effect is applied.",
           "guard": "SetImmediateActionPoint"
         },
+        {
+          "name": "FocusLevelsMode",
+          "type": "ENameArrayEditMode",
+          "kind": "mode",
+          "description": "X2Effect_TemplarFocus (merged by position: entry N is focus level N)"
+        },
+        {
+          "name": "FocusLevels",
+          "type": "array<FocusLevelModifiers>",
+          "kind": "modedArray",
+          "description": "One entry per focus level from level 0: the stat changes, armor mitigation and bonus weapon damage granted at that level. Merge overwrites the level at the same position or appends it.",
+          "modeField": "FocusLevelsMode",
+          "modeEnum": "ENameArrayEditMode"
+        },
         {
           "name": "ApplyAsTarget",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply the modifiers to attacks against the unit rather than attacks it makes.",
           "guard": "SetApplyAsTarget"
         },
         {
           "name": "ConeLength",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Length of the marked cone from the source to the target.",
           "guard": "SetConeLength"
         },
         {
           "name": "ConeEndDiameter",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Diameter of the marked cone at its far end.",
           "guard": "SetConeEndDiameter"
         },
         {
           "name": "PassTargetAsSource",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fire the event with the target as its source.",
           "guard": "SetPassTargetAsSource"
         },
         {
           "name": "ActionPointType",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Type of action point added, or removed, at the start of the turn.",
           "guard": "SetActionPointType"
         },
         {
           "name": "ActionPointsRemoved",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Remove the action points instead of adding them.",
           "guard": "SetActionPointsRemoved"
         },
         {
           "name": "MovingVanishRevealAdditiveAnimName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Additive animation played on reveal when the unit is revealed while moving.",
           "guard": "SetMovingVanishRevealAdditiveAnimName"
         },
         {
           "name": "DamagePerAction",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Damage dealt for each action point stolen.",
           "guard": "SetDamagePerAction"
         },
         {
           "name": "HealthReturnMod",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fraction of the damage dealt that is returned to the source as health.",
           "guard": "SetHealthReturnMod"
         },
         {
           "name": "WallBreakingEffectName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Name of the effect on the unit that grants wall breaking.",
           "guard": "SetWallBreakingEffectName"
         },
         {
           "name": "CenterTile",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Apply the world effect to the centre tile only.",
           "guard": "SetCenterTile"
         },
         {
@@ -3565,7 +3786,7 @@
           "name": "StatTypesToRestore",
           "type": "array<ECharStatType>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Stats reset to their default value while the effect lasts.",
           "modeField": "StatTypesToRestoreMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3620,154 +3841,154 @@
           "name": "IndirectFire",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Treats the attack as indirect, like a grenade: it always hits, though crit, dodge and armour mitigation still apply.",
           "guard": "SetIndirectFire"
         },
         {
           "name": "MeleeAttack",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Treats the attack as melee, which ignores cover and applies the intrinsic melee hit bonus.",
           "guard": "SetMeleeAttack"
         },
         {
           "name": "ReactionFire",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Treats the attack as reaction fire, which takes the reaction penalty and forgoes the flanking bonus.",
           "guard": "SetReactionFire"
         },
         {
           "name": "AllowCrit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Whether crits are built into the hit table at all. Turning it off makes the ability incapable of critting.",
           "guard": "SetAllowCrit"
         },
         {
           "name": "HitsAreCrits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Converts every successful hit into a crit after the roll is made.",
           "guard": "SetHitsAreCrits"
         },
         {
           "name": "MultiTargetOnly",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Guarantees success when the ability has no primary target, for abilities that only ever hit multi-targets.",
           "guard": "SetMultiTargetOnly"
         },
         {
           "name": "OnlyMultiHitWithSuccess",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Multi-target hits only land if the roll succeeded, as with Faceoff.",
           "guard": "SetOnlyMultiHitWithSuccess"
         },
         {
           "name": "GuaranteedHit",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Always hits, skipping the normal hit modifiers. Armour mitigation still rolls.",
           "guard": "SetGuaranteedHit"
         },
         {
           "name": "IgnoreCoverBonus",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Ignores the target's high and low cover bonuses.",
           "guard": "SetIgnoreCoverBonus"
         },
         {
           "name": "FinalMultiplier",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Scales the final hit chance after everything else. Appears in the shot breakdown attributed to the ability.",
           "guard": "SetFinalMultiplier"
         },
         {
           "name": "BuiltInHitMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Flat aim modifier the ability always carries.",
           "guard": "SetBuiltInHitMod"
         },
         {
           "name": "BuiltInCritMod",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Flat crit modifier the ability always carries.",
           "guard": "SetBuiltInCritMod"
         },
         {
           "name": "PercentToHit",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Flat percentage chance to hit, ignoring aim entirely. For abilities whose odds are fixed rather than calculated.",
           "guard": "SetPercentToHit"
         },
         {
           "name": "NoGameStateOnMiss",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Produces no game state at all on a miss, so nothing is recorded or visualised.",
           "guard": "SetNoGameStateOnMiss"
         },
         {
           "name": "FocusMultiplier",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percentage points added to the hit chance per point of Templar focus.",
           "guard": "SetFocusMultiplier"
         },
         {
           "name": "PercentToHitInBuddyZone",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Replaces PercentToHit when the target is inside the buddy zone.",
           "guard": "SetPercentToHitInBuddyZone"
         },
         {
           "name": "AlwaysSucceed",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Makes the hack always succeed.",
           "guard": "SetAlwaysSucceed"
         },
         {
           "name": "StatToRoll",
           "type": "ECharStatType",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Which unit stat the roll is made against.",
           "guard": "SetStatToRoll"
         },
         {
           "name": "BaseChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Base percentage before the stat is taken into account.",
           "guard": "SetBaseChance"
         },
         {
           "name": "BaseValue",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Base value the stat contest is measured against.",
           "guard": "SetBaseValue"
         },
         {
           "name": "AttackerStat",
           "type": "ECharStatType",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Attacker's stat in a unit-versus-unit contest.",
           "guard": "SetAttackerStat"
         },
         {
           "name": "DefenderStat",
           "type": "ECharStatType",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Defender's stat in a unit-versus-unit contest.",
           "guard": "SetDefenderStat"
         },
         {
@@ -3791,70 +4012,70 @@
           "name": "OnlyIncludeTargetsInsideWeaponRange",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Excludes targets beyond the weapon's range from selection.",
           "guard": "SetOnlyIncludeTargetsInsideWeaponRange"
         },
         {
           "name": "AllowInteractiveObjects",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lets the ability target interactive objects such as doors and consoles.",
           "guard": "SetAllowInteractiveObjects"
         },
         {
           "name": "AllowDestructibleObjects",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lets the ability target destructible scenery.",
           "guard": "SetAllowDestructibleObjects"
         },
         {
           "name": "IncludeSelf",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lets the user target itself.",
           "guard": "SetIncludeSelf"
         },
         {
           "name": "ShowAOE",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Draws the area-of-effect preview while aiming.",
           "guard": "SetShowAOE"
         },
         {
           "name": "RestrictToWeaponRange",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Limits the cursor to the weapon's range.",
           "guard": "SetRestrictToWeaponRange"
         },
         {
           "name": "IncreaseWeaponRange",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Extra range in tiles beyond the weapon's own, when restricted to weapon range.",
           "guard": "SetIncreaseWeaponRange"
         },
         {
           "name": "RestrictToSquadsightRange",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Limits the cursor to squadsight range rather than the weapon's.",
           "guard": "SetRestrictToSquadsightRange"
         },
         {
           "name": "FixedAbilityRange",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Fixed range in tiles, ignoring the weapon entirely.",
           "guard": "SetFixedAbilityRange"
         },
         {
           "name": "MovementRangeAdjustment",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Tiles added to or removed from how far the unit may move to reach a melee target.",
           "guard": "SetMovementRangeAdjustment"
         },
         {
@@ -3878,77 +4099,77 @@
           "name": "AllowSameTarget",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lets the primary target also be picked up as a multi-target.",
           "guard": "SetAllowSameTarget"
         },
         {
           "name": "UseSourceWeaponLocation",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Measures the area from the shooter's weapon rather than the unit.",
           "guard": "SetUseSourceWeaponLocation"
         },
         {
           "name": "NumTargetsRequired",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Minimum targets that must be in the area for the ability to be usable.",
           "guard": "SetNumTargetsRequired"
         },
         {
           "name": "UseWeaponRadius",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Takes the radius from the weapon. TargetRadius is then added on top.",
           "guard": "SetUseWeaponRadius"
         },
         {
           "name": "UseWeaponBlockingCoverFlag",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Takes the weapon's setting for whether cover blocks the area.",
           "guard": "SetUseWeaponBlockingCoverFlag"
         },
         {
           "name": "IgnoreBlockingCover",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Lets the area pass through cover that would otherwise block it.",
           "guard": "SetIgnoreBlockingCover"
         },
         {
           "name": "TargetRadius",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.",
           "guard": "SetTargetRadius"
         },
         {
           "name": "TargetCoveragePercentage",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "How much of a tile the area must cover before that tile counts as affected.",
           "guard": "SetTargetCoveragePercentage"
         },
         {
           "name": "AddPrimaryTargetAsMultiTarget",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.",
           "guard": "SetAddPrimaryTargetAsMultiTarget"
         },
         {
           "name": "AllowDeadMultiTargetUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Includes already-dead units in the area.",
           "guard": "SetAllowDeadMultiTargetUnits"
         },
         {
           "name": "ExcludeSelfAsTargetIfWithinRadius",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Leaves the user out of its own area of effect.",
           "guard": "SetExcludeSelfAsTargetIfWithinRadius"
         },
         {
@@ -3961,7 +4182,7 @@
           "name": "AbilityBonusRadii",
           "type": "array<AbilityGrantedBonusRadius>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Extra radius granted when the unit has a particular ability, merged by RequiredAbility. Lets a perk widen the blast without a separate ability.",
           "modeField": "AbilityBonusRadiiMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -3969,28 +4190,28 @@
           "name": "ConeEndDiameter",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Width of the cone at its far end, in metres.",
           "guard": "SetConeEndDiameter"
         },
         {
           "name": "ConeLength",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "How far the cone reaches, in metres.",
           "guard": "SetConeLength"
         },
         {
           "name": "UseWeaponRangeForLength",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Takes the cone's length from the weapon's range instead of ConeLength.",
           "guard": "SetUseWeaponRangeForLength"
         },
         {
           "name": "LockShooterZ",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Restricts the cone to tiles at the shooter's own height, so it does not spread up or down floors.",
           "guard": "SetLockShooterZ"
         },
         {
@@ -4003,7 +4224,7 @@
           "name": "AbilityBonusCones",
           "type": "array<AbilityGrantedBonusCone>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Extra cone length and width granted by a particular ability, merged by RequiredAbility.",
           "modeField": "AbilityBonusConesMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -4011,14 +4232,14 @@
           "name": "TileWidthExtension",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Extra tiles of width added to the line.",
           "guard": "SetTileWidthExtension"
         },
         {
           "name": "SightRangeLimited",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Stops the line at the limit of sight.",
           "guard": "SetSightRangeLimited"
         },
         {
@@ -4031,7 +4252,7 @@
           "name": "AbilityBonusWidths",
           "type": "array<AbilityGrantedBonusWidth>",
           "kind": "modedArray",
-          "description": "",
+          "description": "Extra line width granted by a particular ability, merged by RequiredAbility.",
           "modeField": "AbilityBonusWidthsMode",
           "modeEnum": "ENameArrayEditMode"
         },
@@ -4039,98 +4260,98 @@
           "name": "TargetHeight",
           "type": "float",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Height of the cylinder in metres.",
           "guard": "SetTargetHeight"
         },
         {
           "name": "UseOnlyGroundTiles",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Restricts the cylinder to ground-level tiles.",
           "guard": "SetUseOnlyGroundTiles"
         },
         {
           "name": "NumExtraShots",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Additional shots fired at the same target beyond the first.",
           "guard": "SetNumExtraShots"
         },
         {
           "name": "OnlyAllyOfType",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Restricts targeting to allies of this character type.",
           "guard": "SetOnlyAllyOfType"
         },
         {
           "name": "AcceptFriendlyUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Includes friendly units.",
           "guard": "SetAcceptFriendlyUnits"
         },
         {
           "name": "AcceptEnemyUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Includes hostile units.",
           "guard": "SetAcceptEnemyUnits"
         },
         {
           "name": "OnlyAcceptRoboticUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Restricts targeting to robotic units.",
           "guard": "SetOnlyAcceptRoboticUnits"
         },
         {
           "name": "OnlyAcceptAlienUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Restricts targeting to aliens.",
           "guard": "SetOnlyAcceptAlienUnits"
         },
         {
           "name": "OnlyAcceptAdventUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Restricts targeting to ADVENT units.",
           "guard": "SetOnlyAcceptAdventUnits"
         },
         {
           "name": "RandomlySelectOne",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Picks a single target at random from everything that qualified.",
           "guard": "SetRandomlySelectOne"
         },
         {
           "name": "DontAcceptNeutralUnits",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Leaves civilians and other neutrals out.",
           "guard": "SetDontAcceptNeutralUnits"
         },
         {
           "name": "RandomChance",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Percentage chance each qualifying unit is actually included.",
           "guard": "SetRandomChance"
         },
         {
           "name": "UseAbilitySourceAsPrimaryTarget",
           "type": "bool",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Treats the ability's user as the primary target.",
           "guard": "SetUseAbilitySourceAsPrimaryTarget"
         },
         {
           "name": "ClaymoreEnvironmentalDamage",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Environmental damage the claymore blast does to scenery.",
           "guard": "SetClaymoreEnvironmentalDamage"
         },
         {
@@ -4160,49 +4381,49 @@
           "name": "Priority",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Order this trigger runs in relative to others on the same event. Lower runs first.",
           "guard": "SetPriority"
         },
         {
           "name": "ListenerEventID",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Event this listener waits for. The handling function can only be assigned in code, so a listener added purely from config never fires - editing an existing one does.",
           "guard": "SetListenerEventID"
         },
         {
           "name": "ListenerDeferral",
           "type": "EventListenerDeferral",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "When the listener runs relative to the event being processed.",
           "guard": "SetListenerDeferral"
         },
         {
           "name": "ListenerFilter",
           "type": "AbilityEventFilter",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Which units the event is accepted from, such as only the source or only the target.",
           "guard": "SetListenerFilter"
         },
         {
           "name": "ListenerPriority",
           "type": "int",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Order among listeners for the same event.",
           "guard": "SetListenerPriority"
         },
         {
           "name": "MethodName",
           "type": "name",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Method on the observer class that the trigger calls.",
           "guard": "SetMethodName"
         },
         {
           "name": "EventObserverClass",
           "type": "string",
           "kind": "optionalScalar",
-          "description": "",
+          "description": "Class that observes the event. Loaded by name at runtime.",
           "guard": "SetEventObserverClass"
         },
         {
@@ -5146,6 +5367,54 @@
         "name": "ChosenTraitForceLevelGate",
         "reason": "not covered (deliberate core-set choice)"
       },
+      {
+        "name": "LocFriendlyName",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocHelpText",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocLongDescription",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocPromotionPopupText",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocFlyOverText",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocMissMessage",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocHitMessage",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocFriendlyNameWhenConcealed",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocLongDescriptionWhenConcealed",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocDefaultSoldierClass",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocDefaultPrimaryWeapon",
+        "reason": "localized &mdash; use .int localization files"
+      },
+      {
+        "name": "LocDefaultSecondaryWeapon",
+        "reason": "localized &mdash; use .int localization files"
+      },
       {
         "name": "HideErrors",
         "reason": "not covered (deliberate core-set choice)"
@@ -5472,7 +5741,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5482,7 +5751,7 @@
               "gameField": "iAmmo",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ammo consumed per use. With ConsumeAllAmmo set this becomes the minimum needed to fire, rather than the amount spent.",
               "guard": "SetNumAmmo"
             },
             {
@@ -5492,7 +5761,7 @@
               "gameField": "UseLoadedAmmo",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Draws from the loaded grenade rather than the weapon's ammo, for grenade-launcher abilities.",
               "guard": "SetUseLoadedAmmo"
             },
             {
@@ -5502,7 +5771,7 @@
               "gameField": "bReturnChargesError",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reports a shortfall as \"out of charges\" instead of \"out of ammo\", for abilities presented to the player as charge-based.",
               "guard": "SetReturnChargesError"
             },
             {
@@ -5512,7 +5781,7 @@
               "gameField": "bConsumeAllAmmo",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Spends the whole magazine. NumAmmo then only sets the minimum required to fire.",
               "guard": "SetConsumeAllAmmo"
             }
           ],
@@ -5532,7 +5801,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5542,7 +5811,7 @@
               "gameField": "NumCharges",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Charges consumed per use.",
               "guard": "SetNumCharges"
             },
             {
@@ -5552,7 +5821,7 @@
               "gameField": "bOnlyOnHit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only spends the charge when the ability hits, so a miss costs nothing.",
               "guard": "SetOnlyOnHit"
             },
             {
@@ -5562,7 +5831,7 @@
               "gameField": "bAlsoExpendChargesOnSharedBondmateAbility",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Also spends the bondmate's charges of the shared ability.",
               "guard": "SetAlsoExpendChargesOnSharedBondmateAbility"
             },
             {
@@ -5572,7 +5841,7 @@
               "gameField": "SharedAbilityCharges",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Other abilities whose charges are spent alongside this one, as Skulljack and Skullmine share a pool. Applied when paying, never when checking affordability.",
               "modeField": "SharedAbilityChargesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -5593,7 +5862,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             }
           ],
@@ -5613,7 +5882,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5623,7 +5892,7 @@
               "gameField": "FocusAmount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Templar focus consumed.",
               "guard": "SetFocusAmount"
             },
             {
@@ -5633,7 +5902,7 @@
               "gameField": "ConsumeAllFocus",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Spends the user's entire focus pool rather than FocusAmount.",
               "guard": "SetConsumeAllFocus"
             },
             {
@@ -5643,7 +5912,7 @@
               "gameField": "GhostOnlyCost",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only charges focus to a Ghost, leaving the original Templar's pool untouched.",
               "guard": "SetGhostOnlyCost"
             }
           ],
@@ -5663,7 +5932,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5673,7 +5942,7 @@
               "gameField": "iNumPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action points the ability consumes.",
               "guard": "SetNumPoints"
             },
             {
@@ -5683,7 +5952,7 @@
               "gameField": "bConsumeAllPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ends the turn by consuming every remaining action point, rather than just NumPoints.",
               "guard": "SetConsumeAllPoints"
             },
             {
@@ -5693,7 +5962,7 @@
               "gameField": "AllowedTypes",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action point types that may pay this cost. Restricting it stops the ability being paid for with, say, a Run-and-Gun point.",
               "modeField": "AllowedTypesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -5714,7 +5983,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5724,7 +5993,7 @@
               "gameField": "iNumPoints",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Action points the ability consumes.",
               "guard": "SetNumPoints"
             },
             {
@@ -5734,7 +6003,7 @@
               "gameField": "bConsumeAllPoints",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Ends the turn by consuming every remaining action point, rather than just NumPoints.",
               "guard": "SetConsumeAllPoints"
             },
             {
@@ -5744,7 +6013,7 @@
               "gameField": "bAddWeaponTypicalCost",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Adds the weapon's own typical action cost on top of NumPoints.",
               "guard": "SetAddWeaponTypicalCost"
             },
             {
@@ -5754,7 +6023,7 @@
               "gameField": "bMoveCost",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Treats the cost as movement, so effects and abilities that key off moving apply.",
               "guard": "SetMoveCost"
             },
             {
@@ -5764,7 +6033,7 @@
               "gameField": "AllowedTypes",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Action point types that may pay this cost. Restricting it stops the ability being paid for with, say, a Run-and-Gun point.",
               "modeField": "AllowedTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -5775,7 +6044,7 @@
               "gameField": "DoNotConsumeAllEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "If the user is under any of these effects, ConsumeAllPoints is ignored and the turn does not end.",
               "modeField": "DoNotConsumeAllEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -5786,7 +6055,7 @@
               "gameField": "DoNotConsumeAllSoldierAbilities",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "If the user has any of these abilities, ConsumeAllPoints is ignored. This is how Blademaster lets Slash keep the turn going.",
               "modeField": "DoNotConsumeAllSoldierAbilitiesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -5807,7 +6076,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5817,7 +6086,7 @@
               "gameField": "iNumPoints",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Action points the ability consumes.",
               "guard": "SetNumPoints"
             },
             {
@@ -5827,7 +6096,7 @@
               "gameField": "bConsumeAllPoints",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Ends the turn by consuming every remaining action point, rather than just NumPoints.",
               "guard": "SetConsumeAllPoints"
             },
             {
@@ -5837,7 +6106,7 @@
               "gameField": "bAddWeaponTypicalCost",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Adds the weapon's own typical action cost on top of NumPoints.",
               "guard": "SetAddWeaponTypicalCost"
             },
             {
@@ -5847,7 +6116,7 @@
               "gameField": "bMoveCost",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Treats the cost as movement, so effects and abilities that key off moving apply.",
               "guard": "SetMoveCost"
             },
             {
@@ -5857,7 +6126,7 @@
               "gameField": "AllowedTypes",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "Action point types that may pay this cost. Restricting it stops the ability being paid for with, say, a Run-and-Gun point.",
               "modeField": "AllowedTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -5868,7 +6137,7 @@
               "gameField": "DoNotConsumeAllEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "If the user is under any of these effects, ConsumeAllPoints is ignored and the turn does not end.",
               "modeField": "DoNotConsumeAllEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -5879,7 +6148,7 @@
               "gameField": "DoNotConsumeAllSoldierAbilities",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCostEditor_ActionPoints",
-              "description": "",
+              "description": "If the user has any of these abilities, ConsumeAllPoints is ignored. This is how Blademaster lets Slash keep the turn going.",
               "modeField": "DoNotConsumeAllSoldierAbilitiesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -5900,7 +6169,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             },
             {
@@ -5910,7 +6179,7 @@
               "gameField": "iNumPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action points the ability consumes.",
               "guard": "SetNumPoints"
             },
             {
@@ -5920,7 +6189,7 @@
               "gameField": "bConsumeAllPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ends the turn by consuming every remaining action point, rather than just NumPoints.",
               "guard": "SetConsumeAllPoints"
             },
             {
@@ -5930,7 +6199,7 @@
               "gameField": "bAddWeaponTypicalCost",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Adds the weapon's own typical action cost on top of NumPoints.",
               "guard": "SetAddWeaponTypicalCost"
             },
             {
@@ -5940,7 +6209,7 @@
               "gameField": "bMoveCost",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Treats the cost as movement, so effects and abilities that key off moving apply.",
               "guard": "SetMoveCost"
             },
             {
@@ -5950,7 +6219,7 @@
               "gameField": "AllowedTypes",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action point types that may pay this cost. Restricting it stops the ability being paid for with, say, a Run-and-Gun point.",
               "modeField": "AllowedTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -5961,7 +6230,7 @@
               "gameField": "DoNotConsumeAllEffects",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "If the user is under any of these effects, ConsumeAllPoints is ignored and the turn does not end.",
               "modeField": "DoNotConsumeAllEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -5972,7 +6241,7 @@
               "gameField": "DoNotConsumeAllSoldierAbilities",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "If the user has any of these abilities, ConsumeAllPoints is ignored. This is how Blademaster lets Slash keep the turn going.",
               "modeField": "DoNotConsumeAllSoldierAbilitiesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -5993,7 +6262,7 @@
               "gameField": "bFreeCost",
               "origin": "base",
               "inheritedFrom": "X2AbilityCostEditor",
-              "description": "",
+              "description": "Makes the ability cost nothing. The ability must satisfy the requirement to be usable, but using it doesn't consume action point.",
               "guard": "SetFreeCost"
             }
           ]
@@ -6028,7 +6297,7 @@
               "gameField": "iNumTurns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Turns the ability is unavailable after use.",
               "guard": "SetNumTurns"
             },
             {
@@ -6038,7 +6307,7 @@
               "gameField": "bDoNotApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
               "guard": "SetIgnoreOnHit"
             },
             {
@@ -6048,7 +6317,7 @@
               "gameField": "AditionalAbilityCooldowns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
               "modeField": "AdditionalCooldownMode",
               "modeEnum": "EAdditionalCooldownEditMode"
             }
@@ -6069,7 +6338,7 @@
               "gameField": "iNumTurns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Turns the ability is unavailable after use.",
               "guard": "SetNumTurns"
             },
             {
@@ -6079,7 +6348,7 @@
               "gameField": "bDoNotApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
               "guard": "SetIgnoreOnHit"
             },
             {
@@ -6089,7 +6358,7 @@
               "gameField": "AditionalAbilityCooldowns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
               "modeField": "AdditionalCooldownMode",
               "modeEnum": "EAdditionalCooldownEditMode"
             },
@@ -6100,7 +6369,7 @@
               "gameField": "iNumTurnsForAI",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Cooldown used when the unit is AI-controlled, letting XCOM and the enemy run different timings. Only on X2AbilityCooldown_PerPlayerType.",
               "guard": "SetNumTurnsForAI"
             },
             {
@@ -6110,7 +6379,7 @@
               "gameField": "NumGlobalTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityCooldownEditor_LocalAndGlobal",
-              "description": "",
+              "description": "Cooldown applied across every unit on the team, not just the one that used the ability. Only on the global cooldown classes.",
               "guard": "SetNumGlobalTurns"
             }
           ],
@@ -6130,7 +6399,7 @@
               "gameField": "iNumTurns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Turns the ability is unavailable after use.",
               "guard": "SetNumTurns"
             },
             {
@@ -6140,7 +6409,7 @@
               "gameField": "bDoNotApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
               "guard": "SetIgnoreOnHit"
             },
             {
@@ -6150,7 +6419,7 @@
               "gameField": "AditionalAbilityCooldowns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
               "modeField": "AdditionalCooldownMode",
               "modeEnum": "EAdditionalCooldownEditMode"
             },
@@ -6161,7 +6430,7 @@
               "gameField": "NumGlobalTurns",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Cooldown applied across every unit on the team, not just the one that used the ability. Only on the global cooldown classes.",
               "guard": "SetNumGlobalTurns"
             }
           ],
@@ -6181,7 +6450,7 @@
               "gameField": "iNumTurns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Turns the ability is unavailable after use.",
               "guard": "SetNumTurns"
             },
             {
@@ -6191,7 +6460,7 @@
               "gameField": "bDoNotApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
               "guard": "SetIgnoreOnHit"
             },
             {
@@ -6201,7 +6470,7 @@
               "gameField": "AditionalAbilityCooldowns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
               "modeField": "AdditionalCooldownMode",
               "modeEnum": "EAdditionalCooldownEditMode"
             }
@@ -6222,7 +6491,7 @@
               "gameField": "iNumTurns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Turns the ability is unavailable after use.",
               "guard": "SetNumTurns"
             },
             {
@@ -6232,7 +6501,7 @@
               "gameField": "bDoNotApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
               "guard": "SetIgnoreOnHit"
             },
             {
@@ -6242,7 +6511,7 @@
               "gameField": "AditionalAbilityCooldowns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
               "modeField": "AdditionalCooldownMode",
               "modeEnum": "EAdditionalCooldownEditMode"
             }
@@ -6263,7 +6532,7 @@
               "gameField": "iNumTurns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Turns the ability is unavailable after use.",
               "guard": "SetNumTurns"
             },
             {
@@ -6273,7 +6542,7 @@
               "gameField": "bDoNotApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Skips applying the cooldown when the ability hits, so only a miss puts it on cooldown.",
               "guard": "SetIgnoreOnHit"
             },
             {
@@ -6283,7 +6552,7 @@
               "gameField": "AditionalAbilityCooldowns",
               "origin": "base",
               "inheritedFrom": "X2AbilityCooldownEditor",
-              "description": "",
+              "description": "Cooldowns this ability also puts on *other* abilities, keyed by AbilityName. Used where firing one thing should lock out another.",
               "modeField": "AdditionalCooldownMode",
               "modeEnum": "EAdditionalCooldownEditMode"
             }
@@ -6319,7 +6588,7 @@
               "gameField": "InitialCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Charges the ability starts a mission with.",
               "guard": "SetInitialCharges"
             },
             {
@@ -6329,13 +6598,18 @@
               "gameField": "BonusCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
               "modeField": "BonusChargesMode",
               "modeEnum": "EChargesBonusMode"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "SPAWN_CHARGES",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityChargesEditor_GremlinHeal",
@@ -6350,7 +6624,7 @@
               "gameField": "InitialCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Charges the ability starts a mission with.",
               "guard": "SetInitialCharges"
             },
             {
@@ -6360,7 +6634,7 @@
               "gameField": "BonusCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
               "modeField": "BonusChargesMode",
               "modeEnum": "EChargesBonusMode"
             },
@@ -6371,7 +6645,7 @@
               "gameField": "bStabilize",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Whether the charges behave as the stabilise-style pool, on the charge classes that support it.",
               "guard": "SetStabilize"
             }
           ],
@@ -6391,7 +6665,7 @@
               "gameField": "InitialCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Charges the ability starts a mission with.",
               "guard": "SetInitialCharges"
             },
             {
@@ -6401,7 +6675,7 @@
               "gameField": "BonusCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
               "modeField": "BonusChargesMode",
               "modeEnum": "EChargesBonusMode"
             }
@@ -6422,7 +6696,7 @@
               "gameField": "InitialCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Charges the ability starts a mission with.",
               "guard": "SetInitialCharges"
             },
             {
@@ -6432,7 +6706,7 @@
               "gameField": "BonusCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
               "modeField": "BonusChargesMode",
               "modeEnum": "EChargesBonusMode"
             }
@@ -6453,7 +6727,7 @@
               "gameField": "InitialCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Charges the ability starts a mission with.",
               "guard": "SetInitialCharges"
             },
             {
@@ -6463,13 +6737,18 @@
               "gameField": "BonusCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
               "modeField": "BonusChargesMode",
               "modeEnum": "EChargesBonusMode"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "BASE_CHARGES",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityChargesEditor_Base",
@@ -6484,7 +6763,7 @@
               "gameField": "InitialCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Charges the ability starts a mission with.",
               "guard": "SetInitialCharges"
             },
             {
@@ -6494,7 +6773,7 @@
               "gameField": "BonusCharges",
               "origin": "base",
               "inheritedFrom": "X2AbilityChargesEditor",
-              "description": "",
+              "description": "Extra charges granted when the unit has another ability, keyed by AbilityName. This is how Restoration adds charges to the medikit heal.",
               "modeField": "BonusChargesMode",
               "modeEnum": "EChargesBonusMode"
             }
@@ -6525,19 +6804,29 @@
         "X2AbilityEffectsEditor_Achilles",
         "X2AbilityEffectsEditor_AdverseSoldierClasses",
         "X2AbilityEffectsEditor_Amplify",
+        "X2AbilityEffectsEditor_ApplyAcidToWorld",
         "X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld",
         "X2AbilityEffectsEditor_ApplyFireToWorld",
+        "X2AbilityEffectsEditor_ApplyPoisonToWorld",
+        "X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld",
+        "X2AbilityEffectsEditor_ApplySmokeToWorld",
         "X2AbilityEffectsEditor_APRounds",
         "X2AbilityEffectsEditor_Aura",
         "X2AbilityEffectsEditor_Bewildered",
         "X2AbilityEffectsEditor_BloodTrail",
+        "X2AbilityEffectsEditor_BondmateAimAdjust",
+        "X2AbilityEffectsEditor_BondmateBleedout",
+        "X2AbilityEffectsEditor_CombatStims",
         "X2AbilityEffectsEditor_BonusArmor",
         "X2AbilityEffectsEditor_BonusWeaponDamage",
+        "X2AbilityEffectsEditor_ChryssalidBurrowedAttack",
         "X2AbilityEffectsEditor_ConditionalDamageModifier",
         "X2AbilityEffectsEditor_CoveringFire",
         "X2AbilityEffectsEditor_DamageImmunity",
+        "X2AbilityEffectsEditor_DeadeyeDamage",
         "X2AbilityEffectsEditor_DelayedAbilityActivation",
         "X2AbilityEffectsEditor_FaceMultiRoundTarget",
+        "X2AbilityEffectsEditor_Fortress",
         "X2AbilityEffectsEditor_GenerateCover",
         "X2AbilityEffectsEditor_Groundling",
         "X2AbilityEffectsEditor_Guardian",
@@ -6550,25 +6839,28 @@
         "X2AbilityEffectsEditor_Implacable",
         "X2AbilityEffectsEditor_LaserSight",
         "X2AbilityEffectsEditor_MeleeDamageAdjust",
+        "X2AbilityEffectsEditor_MimicBeacon",
         "X2AbilityEffectsEditor_MindControl",
         "X2AbilityEffectsEditor_ModifyReactionFire",
+        "X2AbilityEffectsEditor_ModifyStatCheckSuccesses",
+        "X2AbilityEffectsEditor_TemplarFocus",
         "X2AbilityEffectsEditor_ModifyStats",
         "X2AbilityEffectsEditor_Nearsighted",
         "X2AbilityEffectsEditor_Needle",
         "X2AbilityEffectsEditor_Oblivious",
+        "X2AbilityEffectsEditor_OverrideDeathAction",
         "X2AbilityEffectsEditor_OverrideDeathAnimOnLoad",
         "X2AbilityEffectsEditor_PaleHorse",
         "X2AbilityEffectsEditor_PersistentSquadViewer",
         "X2AbilityEffectsEditor_PersistentTraversalChange",
         "X2AbilityEffectsEditor_PersistentVoidConduit",
         "X2AbilityEffectsEditor_Possessed",
-        "X2AbilityEffectsEditor_Reaper",
         "X2AbilityEffectsEditor_Regeneration",
         "X2AbilityEffectsEditor_RemoveEffectsByDamageType",
         "X2AbilityEffectsEditor_ReserveOverwatchPoints",
         "X2AbilityEffectsEditor_RunBehaviorTree",
-        "X2AbilityEffectsEditor_ScanningProtocol",
         "X2AbilityEffectsEditor_SmokeGrenade",
+        "X2AbilityEffectsEditor_Solace",
         "X2AbilityEffectsEditor_SpawnDestructible",
         "X2AbilityEffectsEditor_SpawnUnit",
         "X2AbilityEffectsEditor_Stasis",
@@ -6583,12 +6875,14 @@
         "X2AbilityEffectsEditor_TrackingShotMarkTarget",
         "X2AbilityEffectsEditor_TurnStartActionPoints",
         "X2AbilityEffectsEditor_VolatileMix",
+        "X2AbilityEffectsEditor_AlertTheLost",
         "X2AbilityEffectsEditor_ApplyDirectionalWorldDamage",
         "X2AbilityEffectsEditor_ApplyMedikitHeal",
         "X2AbilityEffectsEditor_ApplyWeaponDamage",
         "X2AbilityEffectsEditor_Brutal",
         "X2AbilityEffectsEditor_EnableGlobalAbility",
         "X2AbilityEffectsEditor_GetOverHere",
+        "X2AbilityEffectsEditor_GrantActionPointsWithRecord",
         "X2AbilityEffectsEditor_GrantActionPoints",
         "X2AbilityEffectsEditor_IncreaseBondmateCohesion",
         "X2AbilityEffectsEditor_Knockback",
@@ -6626,7 +6920,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -6636,7 +6930,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -6646,7 +6940,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -6656,7 +6950,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -6666,7 +6960,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -6676,7 +6970,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -6686,7 +6980,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -6696,7 +6990,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -6706,7 +7000,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -6716,7 +7010,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -6726,7 +7020,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -6736,7 +7030,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -6746,7 +7040,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -6756,7 +7050,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -6766,7 +7060,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -6776,7 +7070,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -6786,7 +7080,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -6796,7 +7090,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -6806,7 +7100,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -6826,7 +7120,7 @@
               "gameField": "ObsessedTargetValueName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value holding the object ID of the obsessed-over target.",
               "guard": "SetObsessedTargetValueName"
             },
             {
@@ -6836,7 +7130,7 @@
               "gameField": "bForceReapplyOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
               "guard": "SetCHLForceReapplyOnRefresh"
             },
             {
@@ -6846,7 +7140,7 @@
               "gameField": "m_aStatChanges",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Stat changes applied while the effect lasts, merged by StatType.",
               "modeField": "StatChangeMode",
               "modeEnum": "EStatChangeMode"
             },
@@ -6857,7 +7151,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -6867,7 +7161,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -6877,7 +7171,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -6887,7 +7181,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -6897,7 +7191,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -6907,7 +7201,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -6917,7 +7211,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -6927,7 +7221,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -6937,7 +7231,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -6947,7 +7241,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -6957,7 +7251,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -6967,7 +7261,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -6977,7 +7271,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -6987,7 +7281,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -6997,7 +7291,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -7007,7 +7301,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -7017,7 +7311,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -7027,7 +7321,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -7037,7 +7331,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -7047,7 +7341,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -7057,7 +7351,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -7067,7 +7361,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -7077,7 +7371,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -7087,7 +7381,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -7097,7 +7391,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -7107,7 +7401,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -7117,7 +7411,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -7127,7 +7421,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -7137,7 +7431,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -7147,7 +7441,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -7157,7 +7451,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -7167,7 +7461,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -7177,7 +7471,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -7187,7 +7481,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -7197,7 +7491,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -7207,7 +7501,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -7217,7 +7511,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -7227,7 +7521,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -7237,7 +7531,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -7257,7 +7551,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -7267,7 +7561,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -7277,7 +7571,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -7287,7 +7581,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -7297,7 +7591,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -7307,7 +7601,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -7317,7 +7611,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -7327,7 +7621,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -7337,7 +7631,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -7347,7 +7641,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -7357,7 +7651,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -7367,7 +7661,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -7377,7 +7671,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -7387,7 +7681,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -7397,7 +7691,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -7407,7 +7701,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -7417,7 +7711,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -7427,7 +7721,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -7437,7 +7731,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -7457,7 +7751,7 @@
               "gameField": "ShatteredTargetValueName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value holding the object ID of the unit that shattered the target.",
               "guard": "SetShatteredTargetValueName"
             },
             {
@@ -7467,7 +7761,7 @@
               "gameField": "bForceReapplyOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
               "guard": "SetCHLForceReapplyOnRefresh"
             },
             {
@@ -7477,7 +7771,7 @@
               "gameField": "m_aStatChanges",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Stat changes applied while the effect lasts, merged by StatType.",
               "modeField": "StatChangeMode",
               "modeEnum": "EStatChangeMode"
             },
@@ -7488,7 +7782,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -7498,7 +7792,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -7508,7 +7802,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -7518,7 +7812,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -7528,7 +7822,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -7538,7 +7832,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -7548,7 +7842,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -7558,7 +7852,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -7568,7 +7862,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -7578,7 +7872,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -7588,7 +7882,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -7598,7 +7892,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -7608,7 +7902,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -7618,7 +7912,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -7628,7 +7922,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -7638,7 +7932,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -7648,7 +7942,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -7658,7 +7952,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -7668,7 +7962,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -7678,7 +7972,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -7688,7 +7982,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -7698,7 +7992,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -7708,7 +8002,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -7718,7 +8012,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -7728,7 +8022,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -7738,7 +8032,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -7748,7 +8042,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -7758,7 +8052,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -7768,7 +8062,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -7778,7 +8072,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -7788,7 +8082,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -7798,7 +8092,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -7808,7 +8102,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -7818,7 +8112,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -7828,7 +8122,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -7838,7 +8132,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -7848,7 +8142,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -7858,7 +8152,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -7868,7 +8162,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -7888,7 +8182,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -7898,7 +8192,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -7908,7 +8202,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -7918,7 +8212,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -7928,7 +8222,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -7938,7 +8232,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -7948,7 +8242,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -7958,7 +8252,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -7968,7 +8262,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -7978,7 +8272,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -7988,7 +8282,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -7998,7 +8292,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -8008,7 +8302,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -8018,7 +8312,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -8028,7 +8322,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -8038,7 +8332,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -8048,7 +8342,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -8058,7 +8352,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -8068,7 +8362,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -8088,7 +8382,7 @@
               "gameField": "MovingVanishRevealAdditiveAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Additive animation played on reveal when the unit is revealed while moving.",
               "guard": "SetMovingVanishRevealAdditiveAnimName"
             },
             {
@@ -8098,7 +8392,7 @@
               "gameField": "ReasonNotVisible",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Vanish",
-              "description": "",
+              "description": "Visibility tag given as the reason the vanished unit cannot be seen.",
               "guard": "SetReasonNotVisible"
             },
             {
@@ -8108,7 +8402,7 @@
               "gameField": "VanishRevealAdditiveAnimName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Vanish",
-              "description": "",
+              "description": "Additive animation played on reveal when VanishRevealAnimName is empty.",
               "guard": "SetVanishRevealAdditiveAnimName"
             },
             {
@@ -8118,7 +8412,7 @@
               "gameField": "VanishRevealAnimName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Vanish",
-              "description": "",
+              "description": "Animation played when the unit is revealed.",
               "guard": "SetVanishRevealAnimName"
             },
             {
@@ -8128,7 +8422,7 @@
               "gameField": "VanishSyncAnimName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Vanish",
-              "description": "",
+              "description": "Additive animation played when the vanished state is visualized from a save.",
               "guard": "SetVanishSyncAnimName"
             },
             {
@@ -8138,7 +8432,7 @@
               "gameField": "bForceReapplyOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
               "guard": "SetCHLForceReapplyOnRefresh"
             },
             {
@@ -8148,7 +8442,7 @@
               "gameField": "m_aStatChanges",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Stat changes applied while the effect lasts, merged by StatType.",
               "modeField": "StatChangeMode",
               "modeEnum": "EStatChangeMode"
             },
@@ -8159,7 +8453,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -8169,7 +8463,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -8179,7 +8473,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -8189,7 +8483,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -8199,7 +8493,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -8209,7 +8503,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -8219,7 +8513,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -8229,7 +8523,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -8239,7 +8533,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -8249,7 +8543,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -8259,7 +8553,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -8269,7 +8563,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -8279,7 +8573,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -8289,7 +8583,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -8299,7 +8593,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -8309,7 +8603,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -8319,7 +8613,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -8329,7 +8623,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -8339,7 +8633,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -8349,7 +8643,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -8359,7 +8653,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -8369,7 +8663,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -8379,7 +8673,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -8389,7 +8683,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -8399,7 +8693,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -8409,7 +8703,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -8419,7 +8713,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -8429,7 +8723,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -8439,7 +8733,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -8449,7 +8743,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -8459,7 +8753,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -8469,7 +8763,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -8479,7 +8773,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -8489,7 +8783,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -8499,7 +8793,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -8509,7 +8803,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -8519,7 +8813,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -8529,7 +8823,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -8539,12 +8833,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "PARTINGSILKREVEAL_MIN_TILE_DISTANCE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_KineticPlating",
@@ -8559,7 +8858,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -8569,7 +8868,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -8579,7 +8878,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -8589,7 +8888,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -8599,7 +8898,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -8609,7 +8908,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -8619,7 +8918,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -8629,7 +8928,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -8639,7 +8938,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -8649,7 +8948,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -8659,7 +8958,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -8669,7 +8968,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -8679,7 +8978,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -8689,7 +8988,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -8699,7 +8998,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -8709,7 +9008,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -8719,7 +9018,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -8729,7 +9028,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -8739,7 +9038,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -8759,7 +9058,7 @@
               "gameField": "ShieldPerMiss",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Shield HP gained each time an attack misses the unit.",
               "guard": "SetShieldPerMiss"
             },
             {
@@ -8769,7 +9068,7 @@
               "gameField": "bForceReapplyOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
               "guard": "SetCHLForceReapplyOnRefresh"
             },
             {
@@ -8779,7 +9078,7 @@
               "gameField": "m_aStatChanges",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Stat changes applied while the effect lasts, merged by StatType.",
               "modeField": "StatChangeMode",
               "modeEnum": "EStatChangeMode"
             },
@@ -8790,7 +9089,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -8800,7 +9099,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -8810,7 +9109,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -8820,7 +9119,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -8830,7 +9129,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -8840,7 +9139,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -8850,7 +9149,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -8860,7 +9159,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -8870,7 +9169,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -8880,7 +9179,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -8890,7 +9189,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -8900,7 +9199,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -8910,7 +9209,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -8920,7 +9219,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -8930,7 +9229,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -8940,7 +9239,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -8950,7 +9249,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -8960,7 +9259,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -8970,7 +9269,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -8980,7 +9279,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -8990,7 +9289,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -9000,7 +9299,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -9010,7 +9309,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -9020,7 +9319,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -9030,7 +9329,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -9040,7 +9339,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -9050,7 +9349,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -9060,7 +9359,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -9070,7 +9369,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -9080,7 +9379,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -9090,7 +9389,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -9100,7 +9399,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -9110,7 +9409,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -9120,7 +9419,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -9130,7 +9429,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -9140,7 +9439,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -9150,7 +9449,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -9160,7 +9459,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -9170,7 +9469,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -9190,7 +9489,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -9200,7 +9499,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -9210,7 +9509,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -9220,7 +9519,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -9230,7 +9529,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -9240,7 +9539,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -9250,7 +9549,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -9260,7 +9559,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -9270,7 +9569,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -9280,7 +9579,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -9290,7 +9589,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -9300,7 +9599,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -9310,7 +9609,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -9320,7 +9619,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -9330,7 +9629,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -9340,7 +9639,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -9350,7 +9649,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -9360,7 +9659,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -9370,7 +9669,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -9390,7 +9689,7 @@
               "gameField": "ReasonNotVisible",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Visibility tag given as the reason the vanished unit cannot be seen.",
               "guard": "SetReasonNotVisible"
             },
             {
@@ -9400,7 +9699,7 @@
               "gameField": "VanishRevealAdditiveAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Additive animation played on reveal when VanishRevealAnimName is empty.",
               "guard": "SetVanishRevealAdditiveAnimName"
             },
             {
@@ -9410,7 +9709,7 @@
               "gameField": "VanishRevealAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Animation played when the unit is revealed.",
               "guard": "SetVanishRevealAnimName"
             },
             {
@@ -9420,7 +9719,7 @@
               "gameField": "VanishSyncAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Additive animation played when the vanished state is visualized from a save.",
               "guard": "SetVanishSyncAnimName"
             },
             {
@@ -9430,7 +9729,7 @@
               "gameField": "bForceReapplyOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
               "guard": "SetCHLForceReapplyOnRefresh"
             },
             {
@@ -9440,7 +9739,7 @@
               "gameField": "m_aStatChanges",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentStatChange",
-              "description": "",
+              "description": "Stat changes applied while the effect lasts, merged by StatType.",
               "modeField": "StatChangeMode",
               "modeEnum": "EStatChangeMode"
             },
@@ -9451,7 +9750,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -9461,7 +9760,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -9471,7 +9770,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -9481,7 +9780,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -9491,7 +9790,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -9501,7 +9800,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -9511,7 +9810,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -9521,7 +9820,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -9531,7 +9830,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -9541,7 +9840,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -9551,7 +9850,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -9561,7 +9860,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -9571,7 +9870,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -9581,7 +9880,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -9591,7 +9890,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -9601,7 +9900,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -9611,7 +9910,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -9621,7 +9920,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -9631,7 +9930,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -9641,7 +9940,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -9651,7 +9950,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -9661,7 +9960,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -9671,7 +9970,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -9681,7 +9980,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -9691,7 +9990,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -9701,7 +10000,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -9711,7 +10010,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -9721,7 +10020,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -9731,7 +10030,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -9741,7 +10040,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -9751,7 +10050,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -9761,7 +10060,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -9771,7 +10070,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -9781,7 +10080,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -9791,7 +10090,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -9801,7 +10100,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -9811,7 +10110,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -9821,7 +10120,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -9831,12 +10130,25 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "COLLISION_MIN_TILE_DISTANCE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "COLLISION_MAX_TILE_DISTANCE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "VANISH_EXCLUDE_EFFECTS",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_BlastPadding",
@@ -9851,7 +10163,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -9861,7 +10173,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -9871,7 +10183,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -9881,7 +10193,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -9891,7 +10203,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -9901,7 +10213,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -9911,7 +10223,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -9921,7 +10233,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -9931,7 +10243,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -9941,7 +10253,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -9951,7 +10263,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -9961,7 +10273,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -9971,7 +10283,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -9981,7 +10293,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -9991,7 +10303,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -10001,7 +10313,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -10011,7 +10323,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -10021,7 +10333,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -10031,7 +10343,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -10051,7 +10363,7 @@
               "gameField": "ExplosiveDamageReduction",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fraction of explosive damage removed.",
               "guard": "SetExplosiveDamageReduction"
             },
             {
@@ -10061,7 +10373,7 @@
               "gameField": "ArmorMitigationAmount",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_BonusArmor",
-              "description": "",
+              "description": "Armor points granted while the effect lasts.",
               "guard": "SetArmorMitigationAmount"
             },
             {
@@ -10071,7 +10383,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -10081,7 +10393,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -10091,7 +10403,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -10101,7 +10413,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -10111,7 +10423,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -10121,7 +10433,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -10131,7 +10443,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -10141,7 +10453,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -10151,7 +10463,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -10161,7 +10473,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -10171,7 +10483,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -10181,7 +10493,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -10191,7 +10503,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -10201,7 +10513,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -10211,7 +10523,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -10221,7 +10533,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -10231,7 +10543,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -10241,7 +10553,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -10251,7 +10563,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -10261,7 +10573,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -10271,7 +10583,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -10281,7 +10593,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -10291,7 +10603,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -10301,7 +10613,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -10311,7 +10623,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -10321,7 +10633,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -10331,7 +10643,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -10341,7 +10653,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -10351,7 +10663,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -10361,7 +10673,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -10371,7 +10683,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -10381,7 +10693,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -10391,7 +10703,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -10401,7 +10713,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -10411,7 +10723,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -10421,7 +10733,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -10431,7 +10743,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -10441,7 +10753,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -10451,12 +10763,21 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "ARMOR_CHANCE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "ARMOR_MITIGATION",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_KillUnit",
@@ -10471,7 +10792,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -10481,7 +10802,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -10491,7 +10812,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -10501,7 +10822,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -10511,7 +10832,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -10521,7 +10842,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -10531,7 +10852,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -10541,7 +10862,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -10551,7 +10872,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -10561,7 +10882,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -10571,7 +10892,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -10581,7 +10902,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -10591,7 +10912,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -10601,7 +10922,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -10611,7 +10932,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -10621,7 +10942,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -10631,7 +10952,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -10641,7 +10962,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -10651,7 +10972,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -10671,7 +10992,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -10681,7 +11002,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -10691,7 +11012,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -10701,7 +11022,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -10711,7 +11032,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -10721,7 +11042,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -10731,7 +11052,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -10741,7 +11062,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -10751,7 +11072,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -10761,7 +11082,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -10771,7 +11092,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -10781,7 +11102,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -10791,7 +11112,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -10801,7 +11122,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -10811,7 +11132,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -10821,7 +11142,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -10831,7 +11152,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -10841,7 +11162,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -10851,7 +11172,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -10861,7 +11182,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -10871,7 +11192,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -10881,7 +11202,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -10891,7 +11212,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -10901,7 +11222,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -10911,7 +11232,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -10921,7 +11242,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -10931,7 +11252,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -10941,7 +11262,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -10951,7 +11272,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -10961,7 +11282,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -10971,7 +11292,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -10981,7 +11302,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -10991,7 +11312,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -11001,7 +11322,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -11011,7 +11332,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -11021,7 +11342,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -11031,7 +11352,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -11041,7 +11362,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -11051,7 +11372,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -11071,7 +11392,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -11081,7 +11402,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -11091,7 +11412,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -11101,7 +11422,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -11111,7 +11432,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -11121,7 +11442,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -11131,7 +11452,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -11141,7 +11462,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -11151,7 +11472,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -11161,7 +11482,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -11171,7 +11492,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -11181,7 +11502,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -11191,7 +11512,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -11201,7 +11522,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -11211,7 +11532,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -11221,7 +11542,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -11231,7 +11552,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -11241,7 +11562,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -11251,7 +11572,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -11264,26 +11585,6 @@
               "inheritedFrom": "X2AbilityEffectsEditor",
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
-            {
-              "config": "ParthenogenicPoisonType",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "ParthenogenicPoisonType",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetParthenogenicPoisonType"
-            },
-            {
-              "config": "ParthenogenicPoisonCocoonSpawnedName",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "ParthenogenicPoisonCocoonSpawnedName",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetParthenogenicPoisonCocoonSpawnedName"
-            },
             {
               "config": "AltUnitToSpawnName",
               "type": "name",
@@ -11291,7 +11592,7 @@
               "gameField": "AltUnitToSpawnName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Character template spawned instead of the usual one, when set.",
               "guard": "SetAltUnitToSpawnName"
             },
             {
@@ -11301,7 +11602,7 @@
               "gameField": "UnitToSpawnName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Character template of the unit spawned.",
               "guard": "SetUnitToSpawnName"
             },
             {
@@ -11311,7 +11612,7 @@
               "gameField": "bClearTileBlockedByTargetUnitFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Spawn on the target's own tile.",
               "guard": "SetClearTileBlockedByTargetUnitFlag"
             },
             {
@@ -11321,7 +11622,7 @@
               "gameField": "bCopyTargetAppearance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Give the spawned unit the target's appearance. Takes precedence over CopySourceAppearance.",
               "guard": "SetCopyTargetAppearance"
             },
             {
@@ -11331,7 +11632,7 @@
               "gameField": "bCopySourceAppearance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Give the spawned unit the source's appearance.",
               "guard": "SetCopySourceAppearance"
             },
             {
@@ -11341,7 +11642,7 @@
               "gameField": "bKnockbackAffectsSpawnLocation",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Spawn where the target ended up after knockback rather than where it was hit.",
               "guard": "SetKnockbackAffectsSpawnLocation"
             },
             {
@@ -11351,7 +11652,7 @@
               "gameField": "bAddToSourceGroup",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Put the spawned unit in the source's AI group.",
               "guard": "SetAddToSourceGroup"
             },
             {
@@ -11361,7 +11662,7 @@
               "gameField": "bCopyReanimatedFromUnit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Copy the reanimated unit's inventory and abilities too, not just its appearance.",
               "guard": "SetCopyReanimatedFromUnit"
             },
             {
@@ -11371,7 +11672,7 @@
               "gameField": "bCopyReanimatedStatsFromUnit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Copy the reanimated unit's stats.",
               "guard": "SetCopyReanimatedStatsFromUnit"
             },
             {
@@ -11381,7 +11682,7 @@
               "gameField": "bSetProcessedScamperAs",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Mark the spawned unit's group as having already scampered, so it does not reveal and scamper on sight.",
               "guard": "SetSetProcessedScamperAs"
             },
             {
@@ -11391,7 +11692,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -11401,7 +11702,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -11411,7 +11712,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -11421,7 +11722,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -11431,7 +11732,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -11441,7 +11742,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -11451,7 +11752,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -11461,7 +11762,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -11471,7 +11772,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -11481,7 +11782,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -11491,7 +11792,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -11501,7 +11802,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -11511,7 +11812,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -11521,7 +11822,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -11531,7 +11832,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -11541,7 +11842,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -11551,7 +11852,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -11561,7 +11862,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -11571,7 +11872,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -11581,7 +11882,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -11591,7 +11892,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -11601,7 +11902,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -11611,7 +11912,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -11621,7 +11922,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -11631,7 +11932,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -11641,7 +11942,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -11651,7 +11952,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -11661,7 +11962,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -11671,7 +11972,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -11681,7 +11982,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -11691,7 +11992,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -11701,7 +12002,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -11711,7 +12012,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -11721,7 +12022,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -11731,7 +12032,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -11741,7 +12042,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -11751,7 +12052,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -11761,7 +12062,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -11771,12 +12072,29 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "ParthenogenicPoisonText",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "ParthenogenicPoisonType",
+              "reason": "not yet supported"
+            },
+            {
+              "name": "ParthenogenicPoisonCocoonSpawnedName",
+              "reason": "not yet supported"
+            },
+            {
+              "name": "DiedWithParthenogenicPoisonTriggerName",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_PersistentStatChange",
@@ -11791,7 +12109,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -11801,7 +12119,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -11811,7 +12129,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -11821,7 +12139,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -11831,7 +12149,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -11841,7 +12159,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -11851,7 +12169,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -11861,7 +12179,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -11871,7 +12189,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -11881,7 +12199,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -11891,7 +12209,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -11901,7 +12219,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -11911,7 +12229,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -11921,7 +12239,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -11931,7 +12249,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -11941,7 +12259,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -11951,7 +12269,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -11961,7 +12279,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -11971,7 +12289,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -11991,7 +12309,7 @@
               "gameField": "bForceReapplyOnRefresh",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Re-apply the stat changes when the effect is refreshed. Community Highlander field.",
               "guard": "SetCHLForceReapplyOnRefresh"
             },
             {
@@ -12001,7 +12319,7 @@
               "gameField": "m_aStatChanges",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Stat changes applied while the effect lasts, merged by StatType.",
               "modeField": "StatChangeMode",
               "modeEnum": "EStatChangeMode"
             },
@@ -12012,7 +12330,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -12022,7 +12340,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -12032,7 +12350,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -12042,7 +12360,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -12052,7 +12370,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -12062,7 +12380,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -12072,7 +12390,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -12082,7 +12400,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -12092,7 +12410,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -12102,7 +12420,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -12112,7 +12430,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -12122,7 +12440,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -12132,7 +12450,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -12142,7 +12460,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -12152,7 +12470,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -12162,7 +12480,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -12172,7 +12490,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -12182,7 +12500,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -12192,7 +12510,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -12202,7 +12520,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -12212,7 +12530,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -12222,7 +12540,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -12232,7 +12550,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -12242,7 +12560,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -12252,7 +12570,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -12262,7 +12580,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -12272,7 +12590,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -12282,7 +12600,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -12292,7 +12610,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -12302,7 +12620,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -12312,7 +12630,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -12322,7 +12640,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -12332,7 +12650,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -12342,7 +12660,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -12352,7 +12670,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -12362,7 +12680,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -12372,7 +12690,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -12382,7 +12700,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -12392,7 +12710,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -12412,7 +12730,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -12422,7 +12740,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -12432,7 +12750,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -12442,7 +12760,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -12452,7 +12770,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -12462,7 +12780,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -12472,7 +12790,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -12482,7 +12800,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -12492,7 +12810,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -12502,7 +12820,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -12512,7 +12830,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -12522,7 +12840,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -12532,7 +12850,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -12542,7 +12860,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -12552,7 +12870,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -12562,7 +12880,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -12572,7 +12890,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -12582,7 +12900,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -12592,7 +12910,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -12612,7 +12930,7 @@
               "gameField": "StatTypesToRestore",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Stats reset to their default value while the effect lasts.",
               "modeField": "StatTypesToRestoreMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -12623,7 +12941,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -12633,7 +12951,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -12643,7 +12961,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -12653,7 +12971,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -12663,7 +12981,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -12673,7 +12991,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -12683,7 +13001,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -12693,7 +13011,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -12703,7 +13021,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -12713,7 +13031,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -12723,7 +13041,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -12733,7 +13051,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -12743,7 +13061,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -12753,7 +13071,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -12763,7 +13081,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -12773,7 +13091,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -12783,7 +13101,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -12793,7 +13111,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -12803,7 +13121,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -12813,7 +13131,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -12823,7 +13141,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -12833,7 +13151,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -12843,7 +13161,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -12853,7 +13171,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -12863,7 +13181,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -12873,7 +13191,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -12883,7 +13201,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -12893,7 +13211,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -12903,7 +13221,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -12913,7 +13231,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -12923,7 +13241,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -12933,7 +13251,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -12943,7 +13261,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -12953,7 +13271,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -12963,7 +13281,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -12973,7 +13291,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -12983,7 +13301,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -12993,7 +13311,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -13003,7 +13321,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -13023,7 +13341,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -13033,7 +13351,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -13043,7 +13361,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -13053,7 +13371,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -13063,7 +13381,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -13073,7 +13391,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -13083,7 +13401,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -13093,7 +13411,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -13103,7 +13421,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -13113,7 +13431,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -13123,7 +13441,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -13133,7 +13451,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -13143,7 +13461,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -13153,7 +13471,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -13163,7 +13481,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -13173,7 +13491,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -13183,7 +13501,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -13193,7 +13511,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -13203,7 +13521,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -13223,7 +13541,7 @@
               "gameField": "AnimationName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reanimation animation played on the corpse.",
               "guard": "SetAnimationName"
             },
             {
@@ -13233,7 +13551,7 @@
               "gameField": "AltUnitToSpawnName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Character template spawned instead of the usual one, when set.",
               "guard": "SetAltUnitToSpawnName"
             },
             {
@@ -13243,7 +13561,7 @@
               "gameField": "StartAnimationMinDelaySec",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Shortest delay, in seconds, before the reanimation animation starts.",
               "guard": "SetStartAnimationMinDelaySec"
             },
             {
@@ -13253,7 +13571,7 @@
               "gameField": "StartAnimationMaxDelaySec",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Longest delay, in seconds, before the reanimation animation starts.",
               "guard": "SetStartAnimationMaxDelaySec"
             },
             {
@@ -13263,7 +13581,7 @@
               "gameField": "UnitToSpawnName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Character template of the unit spawned.",
               "guard": "SetUnitToSpawnName"
             },
             {
@@ -13273,7 +13591,7 @@
               "gameField": "bClearTileBlockedByTargetUnitFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Spawn on the target's own tile.",
               "guard": "SetClearTileBlockedByTargetUnitFlag"
             },
             {
@@ -13283,7 +13601,7 @@
               "gameField": "bCopyTargetAppearance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Give the spawned unit the target's appearance. Takes precedence over CopySourceAppearance.",
               "guard": "SetCopyTargetAppearance"
             },
             {
@@ -13293,7 +13611,7 @@
               "gameField": "bCopySourceAppearance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Give the spawned unit the source's appearance.",
               "guard": "SetCopySourceAppearance"
             },
             {
@@ -13303,7 +13621,7 @@
               "gameField": "bKnockbackAffectsSpawnLocation",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Spawn where the target ended up after knockback rather than where it was hit.",
               "guard": "SetKnockbackAffectsSpawnLocation"
             },
             {
@@ -13313,7 +13631,7 @@
               "gameField": "bAddToSourceGroup",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Put the spawned unit in the source's AI group.",
               "guard": "SetAddToSourceGroup"
             },
             {
@@ -13323,7 +13641,7 @@
               "gameField": "bCopyReanimatedFromUnit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Copy the reanimated unit's inventory and abilities too, not just its appearance.",
               "guard": "SetCopyReanimatedFromUnit"
             },
             {
@@ -13333,7 +13651,7 @@
               "gameField": "bCopyReanimatedStatsFromUnit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Copy the reanimated unit's stats.",
               "guard": "SetCopyReanimatedStatsFromUnit"
             },
             {
@@ -13343,7 +13661,7 @@
               "gameField": "bSetProcessedScamperAs",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Mark the spawned unit's group as having already scampered, so it does not reveal and scamper on sight.",
               "guard": "SetSetProcessedScamperAs"
             },
             {
@@ -13353,7 +13671,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -13363,7 +13681,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -13373,7 +13691,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -13383,7 +13701,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -13393,7 +13711,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -13403,7 +13721,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -13413,7 +13731,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -13423,7 +13741,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -13433,7 +13751,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -13443,7 +13761,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -13453,7 +13771,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -13463,7 +13781,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -13473,7 +13791,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -13483,7 +13801,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -13493,7 +13811,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -13503,7 +13821,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -13513,7 +13831,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -13523,7 +13841,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -13533,7 +13851,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -13543,7 +13861,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -13553,7 +13871,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -13563,7 +13881,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -13573,7 +13891,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -13583,7 +13901,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -13593,7 +13911,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -13603,7 +13921,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -13613,7 +13931,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -13623,7 +13941,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -13633,7 +13951,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -13643,7 +13961,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -13653,7 +13971,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -13663,7 +13981,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -13673,7 +13991,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -13683,7 +14001,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -13693,7 +14011,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -13703,7 +14021,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -13713,7 +14031,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -13723,7 +14041,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -13733,12 +14051,21 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "ZombieFlyoverText",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "TurnedZombieName",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_SpawnShadowbindUnit",
@@ -13753,7 +14080,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -13763,7 +14090,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -13773,7 +14100,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -13783,7 +14110,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -13793,7 +14120,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -13803,7 +14130,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -13813,7 +14140,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -13823,7 +14150,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -13833,7 +14160,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -13843,7 +14170,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -13853,7 +14180,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -13863,7 +14190,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -13873,7 +14200,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -13883,7 +14210,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -13893,7 +14220,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -13903,7 +14230,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -13913,7 +14240,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -13923,7 +14250,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -13933,7 +14260,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -13953,7 +14280,7 @@
               "gameField": "ShadowbindUnconciousCheckName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value checked to tell whether the shadowbound unit was unconscious.",
               "guard": "SetShadowbindUnconciousCheckName"
             },
             {
@@ -13963,7 +14290,7 @@
               "gameField": "UnitToSpawnName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Character template of the unit spawned.",
               "guard": "SetUnitToSpawnName"
             },
             {
@@ -13973,7 +14300,7 @@
               "gameField": "bClearTileBlockedByTargetUnitFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Spawn on the target's own tile.",
               "guard": "SetClearTileBlockedByTargetUnitFlag"
             },
             {
@@ -13983,7 +14310,7 @@
               "gameField": "bCopyTargetAppearance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Give the spawned unit the target's appearance. Takes precedence over CopySourceAppearance.",
               "guard": "SetCopyTargetAppearance"
             },
             {
@@ -13993,7 +14320,7 @@
               "gameField": "bCopySourceAppearance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Give the spawned unit the source's appearance.",
               "guard": "SetCopySourceAppearance"
             },
             {
@@ -14003,7 +14330,7 @@
               "gameField": "bKnockbackAffectsSpawnLocation",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Spawn where the target ended up after knockback rather than where it was hit.",
               "guard": "SetKnockbackAffectsSpawnLocation"
             },
             {
@@ -14013,7 +14340,7 @@
               "gameField": "bAddToSourceGroup",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Put the spawned unit in the source's AI group.",
               "guard": "SetAddToSourceGroup"
             },
             {
@@ -14023,7 +14350,7 @@
               "gameField": "bCopyReanimatedFromUnit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Copy the reanimated unit's inventory and abilities too, not just its appearance.",
               "guard": "SetCopyReanimatedFromUnit"
             },
             {
@@ -14033,7 +14360,7 @@
               "gameField": "bCopyReanimatedStatsFromUnit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Copy the reanimated unit's stats.",
               "guard": "SetCopyReanimatedStatsFromUnit"
             },
             {
@@ -14043,7 +14370,7 @@
               "gameField": "bSetProcessedScamperAs",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_SpawnUnit",
-              "description": "",
+              "description": "Mark the spawned unit's group as having already scampered, so it does not reveal and scamper on sight.",
               "guard": "SetSetProcessedScamperAs"
             },
             {
@@ -14053,7 +14380,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -14063,7 +14390,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -14073,7 +14400,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -14083,7 +14410,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -14093,7 +14420,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -14103,7 +14430,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -14113,7 +14440,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -14123,7 +14450,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -14133,7 +14460,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -14143,7 +14470,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -14153,7 +14480,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -14163,7 +14490,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -14173,7 +14500,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -14183,7 +14510,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -14193,7 +14520,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -14203,7 +14530,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -14213,7 +14540,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -14223,7 +14550,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -14233,7 +14560,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -14243,7 +14570,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -14253,7 +14580,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -14263,7 +14590,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -14273,7 +14600,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -14283,7 +14610,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -14293,7 +14620,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -14303,7 +14630,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -14313,7 +14640,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -14323,7 +14650,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -14333,7 +14660,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -14343,7 +14670,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -14353,7 +14680,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -14363,7 +14690,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -14373,7 +14700,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -14383,7 +14710,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -14393,7 +14720,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -14403,7 +14730,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -14413,7 +14740,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -14423,7 +14750,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -14433,12 +14760,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "AbilitiesShadowCantHave",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_ThreatAssessment",
@@ -14453,7 +14785,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -14463,7 +14795,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -14473,7 +14805,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -14483,7 +14815,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -14493,7 +14825,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -14503,7 +14835,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -14513,7 +14845,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -14523,7 +14855,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -14533,7 +14865,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -14543,7 +14875,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -14553,7 +14885,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -14563,7 +14895,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -14573,7 +14905,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -14583,7 +14915,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -14593,7 +14925,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -14603,7 +14935,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -14613,7 +14945,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -14623,7 +14955,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -14633,7 +14965,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -14653,7 +14985,7 @@
               "gameField": "ImmediateActionPoint",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reserve action point given to the target as soon as the effect is applied.",
               "guard": "SetImmediateActionPoint"
             },
             {
@@ -14663,7 +14995,7 @@
               "gameField": "AbilityToActivate",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Ability fired when the covering fire check matches.",
               "guard": "SetAbilityToActivate"
             },
             {
@@ -14673,7 +15005,7 @@
               "gameField": "GrantActionPoint",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Reserve action point given to the covering unit when the check matches.",
               "guard": "SetGrantActionPoint"
             },
             {
@@ -14683,7 +15015,7 @@
               "gameField": "MaxPointsPerTurn",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Most times per turn the action point can be granted. 0 or less removes the limit.",
               "guard": "SetMaxPointsPerTurn"
             },
             {
@@ -14693,7 +15025,7 @@
               "gameField": "bDirectAttackOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Only match when the unit carrying the effect is attacked directly.",
               "guard": "SetDirectAttackOnly"
             },
             {
@@ -14703,7 +15035,7 @@
               "gameField": "bPreEmptiveFire",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Fire before the attacker's shot resolves instead of after it.",
               "guard": "SetPreEmptiveFire"
             },
             {
@@ -14713,7 +15045,7 @@
               "gameField": "bOnlyDuringEnemyTurn",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Only fire during the enemy turn.",
               "guard": "SetOnlyDuringEnemyTurn"
             },
             {
@@ -14723,7 +15055,7 @@
               "gameField": "bUseMultiTargets",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Fire the ability at the covering unit itself and hit its multi-targets, instead of retaliating at the attacker.",
               "guard": "SetUseMultiTargets"
             },
             {
@@ -14733,7 +15065,7 @@
               "gameField": "bOnlyWhenAttackMisses",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Only fire when the attack missed.",
               "guard": "SetOnlyWhenAttackMisses"
             },
             {
@@ -14743,7 +15075,7 @@
               "gameField": "bSelfTargeting",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "The fired ability targets the covering unit itself.",
               "guard": "SetSelfTargeting"
             },
             {
@@ -14753,7 +15085,7 @@
               "gameField": "ActivationPercentChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_CoveringFire",
-              "description": "",
+              "description": "Percent chance the ability fires when the check matches. 0 always fires.",
               "guard": "SetActivationPercentChance"
             },
             {
@@ -14763,7 +15095,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -14773,7 +15105,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -14783,7 +15115,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -14793,7 +15125,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -14803,7 +15135,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -14813,7 +15145,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -14823,7 +15155,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -14833,7 +15165,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -14843,7 +15175,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -14853,7 +15185,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -14863,7 +15195,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -14873,7 +15205,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -14883,7 +15215,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -14893,7 +15225,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -14903,7 +15235,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -14913,7 +15245,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -14923,7 +15255,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -14933,7 +15265,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -14943,7 +15275,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -14953,7 +15285,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -14963,7 +15295,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -14973,7 +15305,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -14983,7 +15315,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -14993,7 +15325,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -15003,7 +15335,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -15013,7 +15345,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -15023,7 +15355,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -15033,7 +15365,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -15043,7 +15375,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -15053,7 +15385,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -15063,7 +15395,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -15073,7 +15405,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -15083,7 +15415,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -15093,7 +15425,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -15103,7 +15435,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -15113,7 +15445,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -15123,7 +15455,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -15133,7 +15465,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -15143,7 +15475,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -15163,7 +15495,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -15173,7 +15505,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -15183,7 +15515,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -15193,7 +15525,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -15203,7 +15535,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -15213,7 +15545,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -15223,7 +15555,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -15233,7 +15565,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -15243,7 +15575,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -15253,7 +15585,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -15263,7 +15595,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -15273,7 +15605,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -15283,7 +15615,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -15293,7 +15625,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -15303,7 +15635,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -15313,7 +15645,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -15323,7 +15655,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -15333,7 +15665,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -15343,7 +15675,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -15363,7 +15695,7 @@
               "gameField": "WallBreakingEffectName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Name of the effect on the unit that grants wall breaking.",
               "guard": "SetWallBreakingEffectName"
             },
             {
@@ -15373,7 +15705,7 @@
               "gameField": "aTraversalChanges",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_PersistentTraversalChange",
-              "description": "",
+              "description": "Traversal types switched on or off while the effect lasts, merged by Traversal.",
               "modeField": "TraversalChangesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -15384,7 +15716,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -15394,7 +15726,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -15404,7 +15736,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -15414,7 +15746,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -15424,7 +15756,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -15434,7 +15766,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -15444,7 +15776,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -15454,7 +15786,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -15464,7 +15796,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -15474,7 +15806,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -15484,7 +15816,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -15494,7 +15826,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -15504,7 +15836,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -15514,7 +15846,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -15524,7 +15856,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -15534,7 +15866,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -15544,7 +15876,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -15554,7 +15886,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -15564,7 +15896,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -15574,7 +15906,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -15584,7 +15916,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -15594,7 +15926,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -15604,7 +15936,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -15614,7 +15946,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -15624,7 +15956,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -15634,7 +15966,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -15644,7 +15976,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -15654,7 +15986,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -15664,7 +15996,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -15674,7 +16006,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -15684,7 +16016,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -15694,7 +16026,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -15704,7 +16036,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -15714,7 +16046,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -15724,7 +16056,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -15734,7 +16066,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -15744,7 +16076,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -15754,7 +16086,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -15764,7 +16096,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -15784,7 +16116,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -15794,7 +16126,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -15804,7 +16136,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -15814,7 +16146,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -15824,7 +16156,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -15834,7 +16166,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -15844,7 +16176,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -15854,7 +16186,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -15864,7 +16196,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -15874,7 +16206,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -15884,7 +16216,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -15894,7 +16226,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -15904,7 +16236,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -15914,7 +16246,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -15924,7 +16256,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -15934,7 +16266,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -15944,7 +16276,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -15954,7 +16286,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -15964,7 +16296,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -15984,7 +16316,7 @@
               "gameField": "ToHitMin",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lowest hit chance at which the damage multiplier applies.",
               "guard": "SetToHitMin"
             },
             {
@@ -15994,7 +16326,7 @@
               "gameField": "DmgMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier applied to the damage when the effect's condition is met.",
               "guard": "SetDmgMod"
             },
             {
@@ -16004,7 +16336,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -16014,7 +16346,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -16024,7 +16356,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -16034,7 +16366,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -16044,7 +16376,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -16054,7 +16386,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -16064,7 +16396,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -16074,7 +16406,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -16084,7 +16416,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -16094,7 +16426,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -16104,7 +16436,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -16114,7 +16446,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -16124,7 +16456,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -16134,7 +16466,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -16144,7 +16476,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -16154,7 +16486,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -16164,7 +16496,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -16174,7 +16506,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -16184,7 +16516,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -16194,7 +16526,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -16204,7 +16536,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -16214,7 +16546,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -16224,7 +16556,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -16234,7 +16566,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -16244,7 +16576,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -16254,7 +16586,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -16264,7 +16596,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -16274,7 +16606,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -16284,7 +16616,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -16294,7 +16626,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -16304,7 +16636,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -16314,7 +16646,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -16324,7 +16656,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -16334,7 +16666,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -16344,7 +16676,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -16354,7 +16686,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -16364,7 +16696,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -16374,7 +16706,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -16384,7 +16716,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -16404,7 +16736,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -16414,7 +16746,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -16424,7 +16756,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -16434,7 +16766,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -16444,7 +16776,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -16454,7 +16786,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -16464,7 +16796,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -16474,7 +16806,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -16484,7 +16816,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -16494,7 +16826,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -16504,7 +16836,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -16514,7 +16846,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -16524,7 +16856,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -16534,7 +16866,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -16544,7 +16876,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -16554,7 +16886,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -16564,7 +16896,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -16574,7 +16906,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -16584,7 +16916,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -16604,7 +16936,7 @@
               "gameField": "AdverseClasses",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Soldier classes whose attacks trigger the damage multiplier.",
               "modeField": "AdverseClassesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -16615,7 +16947,7 @@
               "gameField": "DmgMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier applied to the damage when the effect's condition is met.",
               "guard": "SetDmgMod"
             },
             {
@@ -16625,7 +16957,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -16635,7 +16967,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -16645,7 +16977,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -16655,7 +16987,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -16665,7 +16997,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -16675,7 +17007,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -16685,7 +17017,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -16695,7 +17027,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -16705,7 +17037,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -16715,7 +17047,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -16725,7 +17057,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -16735,7 +17067,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -16745,7 +17077,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -16755,7 +17087,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -16765,7 +17097,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -16775,7 +17107,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -16785,7 +17117,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -16795,7 +17127,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -16805,7 +17137,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -16815,7 +17147,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -16825,7 +17157,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -16835,7 +17167,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -16845,7 +17177,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -16855,7 +17187,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -16865,7 +17197,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -16875,7 +17207,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -16885,7 +17217,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -16895,7 +17227,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -16905,7 +17237,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -16915,7 +17247,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -16925,7 +17257,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -16935,7 +17267,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -16945,7 +17277,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -16955,7 +17287,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -16965,7 +17297,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -16975,7 +17307,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -16985,7 +17317,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -16995,7 +17327,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -17005,7 +17337,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -17025,7 +17357,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -17035,7 +17367,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -17045,7 +17377,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -17055,7 +17387,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -17065,7 +17397,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -17075,7 +17407,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -17085,7 +17417,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -17095,7 +17427,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -17105,7 +17437,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -17115,7 +17447,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -17125,7 +17457,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -17135,7 +17467,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -17145,7 +17477,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -17155,7 +17487,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -17165,7 +17497,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -17175,7 +17507,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -17185,7 +17517,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -17195,7 +17527,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -17205,7 +17537,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -17225,7 +17557,7 @@
               "gameField": "BonusDamageMult",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fraction of the damage added as bonus.",
               "guard": "SetBonusDamageMult"
             },
             {
@@ -17235,7 +17567,7 @@
               "gameField": "MinBonusDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Smallest bonus damage applied, when the fraction comes out lower.",
               "guard": "SetMinBonusDamage"
             },
             {
@@ -17245,7 +17577,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -17255,7 +17587,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -17265,7 +17597,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -17275,7 +17607,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -17285,7 +17617,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -17295,7 +17627,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -17305,7 +17637,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -17315,7 +17647,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -17325,7 +17657,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -17335,7 +17667,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -17345,7 +17677,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -17355,7 +17687,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -17365,7 +17697,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -17375,7 +17707,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -17385,7 +17717,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -17395,7 +17727,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -17405,7 +17737,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -17415,7 +17747,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -17425,7 +17757,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -17435,7 +17767,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -17445,7 +17777,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -17455,7 +17787,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -17465,7 +17797,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -17475,7 +17807,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -17485,7 +17817,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -17495,7 +17827,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -17505,7 +17837,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -17515,7 +17847,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -17525,7 +17857,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -17535,7 +17867,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -17545,7 +17877,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -17555,7 +17887,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -17565,7 +17897,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -17575,7 +17907,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -17585,7 +17917,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -17595,7 +17927,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -17605,7 +17937,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -17615,7 +17947,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -17625,17 +17957,26 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "AmplifyRemoved",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "AmplifyCountdown",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
-          "class": "X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld",
-          "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_ApplyBlazingPinionsTargetToWorld",
+          "class": "X2AbilityEffectsEditor_ApplyAcidToWorld",
+          "extends": "X2AbilityEffectsEditor_World",
+          "gameClass": "X2Effect_ApplyAcidToWorld",
           "catchAll": false,
           "fields": [
             {
@@ -17645,7 +17986,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -17655,7 +17996,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -17665,7 +18006,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -17675,7 +18016,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -17685,7 +18026,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -17695,7 +18036,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -17705,7 +18046,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -17715,7 +18056,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -17725,7 +18066,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -17735,7 +18076,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -17745,7 +18086,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -17755,7 +18096,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -17765,7 +18106,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -17775,7 +18116,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -17785,7 +18126,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -17795,7 +18136,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -17805,7 +18146,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -17815,7 +18156,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -17825,7 +18166,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -17839,14 +18180,344 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "OverrideParticleSystemFill_Name",
+              "config": "AcidParticleSystem1Tile",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_1pc",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering a single tile.",
+              "guard": "SetAcidParticleSystem1Tile"
+            },
+            {
+              "config": "AcidParticleSystem2Tiles",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_2pc",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering two tiles.",
+              "guard": "SetAcidParticleSystem2Tiles"
+            },
+            {
+              "config": "AcidParticleSystem3TilesLine",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_3pc_Long",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering three tiles in a line.",
+              "guard": "SetAcidParticleSystem3TilesLine"
+            },
+            {
+              "config": "AcidParticleSystem3TilesCorner",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_3pc_Corner",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering three tiles in a corner.",
+              "guard": "SetAcidParticleSystem3TilesCorner"
+            },
+            {
+              "config": "AcidParticleSystem4TilesLine",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_Long",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering four tiles in a line.",
+              "guard": "SetAcidParticleSystem4TilesLine"
+            },
+            {
+              "config": "AcidParticleSystem4TilesSquare",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_Square",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering a 2x2 square.",
+              "guard": "SetAcidParticleSystem4TilesSquare"
+            },
+            {
+              "config": "AcidParticleSystem4TilesL",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_L",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering four tiles in an L shape.",
+              "guard": "SetAcidParticleSystem4TilesL"
+            },
+            {
+              "config": "AcidParticleSystem4TilesReverseL",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_Reverse_L",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering four tiles in a mirrored L shape.",
+              "guard": "SetAcidParticleSystem4TilesReverseL"
+            },
+            {
+              "config": "AcidParticleSystem4TilesT",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_Middle",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering four tiles in a T shape (the game's 4pc_Middle).",
+              "guard": "SetAcidParticleSystem4TilesT"
+            },
+            {
+              "config": "AcidParticleSystem4TilesS",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_S",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering four tiles in an S shape.",
+              "guard": "SetAcidParticleSystem4TilesS"
+            },
+            {
+              "config": "AcidParticleSystem4TilesReverseS",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "AcidParticleSystemFill_Name_4pc_Reverse_S",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for an acid pool covering four tiles in a mirrored S shape.",
+              "guard": "SetAcidParticleSystem4TilesReverseS"
+            },
+            {
+              "config": "CenterTile",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCenterTile",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_World",
+              "description": "Apply the world effect to the centre tile only.",
+              "guard": "SetCenterTile"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_ApplyBlazingPinionsTargetToWorld",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_ApplyBlazingPinionsTargetToWorld",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "OverrideParticleSystem",
               "type": "string",
               "kind": "scalar",
               "gameField": "OverrideParticleSystemFill_Name",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetOverrideParticleSystemFill_Name"
+              "description": "Particle system path played on the target instead of the default one. Empty keeps the default.",
+              "guard": "SetOverrideParticleSystem"
             },
             {
               "config": "InfiniteDuration",
@@ -17855,7 +18526,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -17865,7 +18536,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -17875,7 +18546,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -17885,7 +18556,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -17895,7 +18566,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -17905,7 +18576,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -17915,7 +18586,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -17925,7 +18596,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -17935,7 +18606,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -17945,7 +18616,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -17955,7 +18626,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -17965,7 +18636,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -17975,7 +18646,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -17985,7 +18656,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -17995,7 +18666,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -18005,7 +18676,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -18015,7 +18686,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -18025,7 +18696,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -18035,7 +18706,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -18045,7 +18716,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -18055,7 +18726,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -18065,7 +18736,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -18075,7 +18746,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -18085,7 +18756,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -18095,7 +18766,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -18105,7 +18776,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -18115,7 +18786,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -18125,7 +18796,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -18135,7 +18806,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -18145,7 +18816,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -18155,7 +18826,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -18165,7 +18836,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -18175,7 +18846,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -18185,7 +18856,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -18195,7 +18866,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -18205,7 +18876,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -18215,7 +18886,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -18225,7 +18896,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -18235,12 +18906,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "BlazingPinionsParticleSystemFill_Name",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_ApplyFireToWorld",
@@ -18255,7 +18931,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -18265,7 +18941,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -18275,7 +18951,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -18285,7 +18961,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -18295,7 +18971,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -18305,7 +18981,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -18315,7 +18991,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -18325,7 +19001,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -18335,7 +19011,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -18345,7 +19021,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -18355,7 +19031,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -18365,7 +19041,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -18375,7 +19051,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -18385,7 +19061,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -18395,7 +19071,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -18405,7 +19081,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -18415,7 +19091,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -18425,7 +19101,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -18435,7 +19111,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -18455,7 +19131,7 @@
               "gameField": "FireChance_Level1",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Weight of a level 1 fire when rolling the intensity of new fires; relative to the other two levels.",
               "guard": "SetFireChance_Level1"
             },
             {
@@ -18465,7 +19141,7 @@
               "gameField": "FireChance_Level2",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Weight of a level 2 fire when rolling the intensity of new fires; relative to the other two levels.",
               "guard": "SetFireChance_Level2"
             },
             {
@@ -18475,7 +19151,7 @@
               "gameField": "FireChance_Level3",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Weight of a level 3 fire when rolling the intensity of new fires; relative to the other two levels.",
               "guard": "SetFireChance_Level3"
             },
             {
@@ -18485,7 +19161,7 @@
               "gameField": "bUseFireChanceLevel",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Roll the fire intensity from the three FireChance weights instead of using the default.",
               "guard": "SetUseFireChanceLevel"
             },
             {
@@ -18495,7 +19171,7 @@
               "gameField": "bDamageFragileOnly",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only damage fragile objects.",
               "guard": "SetDamageFragileOnly"
             },
             {
@@ -18505,7 +19181,7 @@
               "gameField": "bCheckForLOSFromTargetLocation",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only set tiles on fire that are visible from the target location.",
               "guard": "SetCheckForLOSFromTargetLocation"
             },
             {
@@ -18515,17 +19191,6295 @@
               "gameField": "bCenterTile",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_World",
-              "description": "",
+              "description": "Apply the world effect to the centre tile only.",
               "guard": "SetCenterTile"
             }
           ],
           "abstract": false,
+          "notEditable": [
+            {
+              "name": "FireParticleSystemFill_Name",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MAX_INTENSITY_2_TILES",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "LimitFireSpreadTiles",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "FillIntensityLERPTimeSecs",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
+        },
+        {
+          "class": "X2AbilityEffectsEditor_ApplyPoisonToWorld",
+          "extends": "X2AbilityEffectsEditor_World",
+          "gameClass": "X2Effect_ApplyPoisonToWorld",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "PoisonParticleSystem",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PoisonParticleSystemFill_Name",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for a poison cloud tile.",
+              "guard": "SetPoisonParticleSystem"
+            },
+            {
+              "config": "CenterTile",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCenterTile",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_World",
+              "description": "Apply the world effect to the centre tile only.",
+              "guard": "SetCenterTile"
+            }
+          ],
+          "abstract": false,
+          "notEditable": [
+            {
+              "name": "Duration",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
+        },
+        {
+          "class": "X2AbilityEffectsEditor_ApplySmokeGrenadeToWorld",
+          "extends": "X2AbilityEffectsEditor_World",
+          "gameClass": "X2Effect_ApplySmokeGrenadeToWorld",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "SmokeParticleSystem",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SmokeParticleSystemFill_Name",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for a smoke tile.",
+              "guard": "SetSmokeParticleSystem"
+            },
+            {
+              "config": "CenterTile",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCenterTile",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_World",
+              "description": "Apply the world effect to the centre tile only.",
+              "guard": "SetCenterTile"
+            }
+          ],
+          "abstract": false,
+          "notEditable": [
+            {
+              "name": "Duration",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
+        },
+        {
+          "class": "X2AbilityEffectsEditor_ApplySmokeToWorld",
+          "extends": "X2AbilityEffectsEditor_World",
+          "gameClass": "X2Effect_ApplySmokeToWorld",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "SmokeParticleSystem",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SmokeParticleSystemFill_Name",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Particle system path for a smoke tile.",
+              "guard": "SetSmokeParticleSystem"
+            },
+            {
+              "config": "CenterTile",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCenterTile",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_World",
+              "description": "Apply the world effect to the centre tile only.",
+              "guard": "SetCenterTile"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_APRounds",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_APRounds",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "Pierce",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "Pierce",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Armor pierced.",
+              "guard": "SetPierce"
+            },
+            {
+              "config": "CritChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "CritChance",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Crit chance added.",
+              "guard": "SetCritChance"
+            },
+            {
+              "config": "CritDamage",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "CritDamage",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Crit damage added.",
+              "guard": "SetCritDamage"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_Aura",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_Aura",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "EventsToUpdate",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "EventsToUpdate",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Events that make the aura re-evaluate which units it covers.",
+              "modeField": "EventsToUpdateMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_Bewildered",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_Bewildered",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "DmgMod",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DmgMod",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Multiplier applied to the damage when the effect's condition is met.",
+              "guard": "SetDmgMod"
+            },
+            {
+              "config": "NumHitsForMod",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "NumHitsForMod",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Hits taken in the turn before the damage multiplier applies.",
+              "guard": "SetNumHitsForMod"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_BloodTrail",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_BloodTrail",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "BonusDamage",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "BonusDamage",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Bonus damage added when the effect's condition is met.",
+              "guard": "SetBonusDamage"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_BondmateAimAdjust",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_BondmateAimAdjust",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "ThreatenedBondmateAimBonus",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ThreatenedBondmateAimBonus",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Aim bonus, from bond level 2, against a target that threatens the bondmate.",
+              "guard": "SetThreatenedBondmateAimBonus"
+            },
+            {
+              "config": "BondmateTargetAimBonus",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "BondmateTargetAimBonus",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Aim bonus, from bond level 3, against a target the bondmate attacked since last turn.",
+              "guard": "SetBondmateTargetAimBonus"
+            },
+            {
+              "config": "BondmateTargetCritBonus",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "BondmateTargetCritBonus",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Crit bonus, from bond level 3, against a target the bondmate attacked since last turn.",
+              "guard": "SetBondmateTargetCritBonus"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_BondmateBleedout",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_BondmateBleedout",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "BleedoutDurationAdjustment",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "BleedoutDurationAdjustment",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Turns added to the bleedout duration.",
+              "guard": "SetBleedoutDurationAdjustment"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_CombatStims",
+          "extends": "X2AbilityEffectsEditor_BonusArmor",
+          "gameClass": "X2Effect_CombatStims",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "DamageTypeImmunities",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypeImmunities",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage types the affected unit is immune to while the effect lasts.",
+              "modeField": "DamageTypeImmunitiesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "ArmorMitigationAmount",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ArmorMitigationAmount",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_BonusArmor",
+              "description": "Armor points granted while the effect lasts.",
+              "guard": "SetArmorMitigationAmount"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": [
+            {
+              "name": "ARMOR_CHANCE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "ARMOR_MITIGATION",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
+        },
+        {
+          "class": "X2AbilityEffectsEditor_BonusArmor",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_BonusArmor",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "ArmorMitigationAmount",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ArmorMitigationAmount",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Armor points granted while the effect lasts.",
+              "guard": "SetArmorMitigationAmount"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_BonusWeaponDamage",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_BonusWeaponDamage",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "BonusDmg",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "BonusDmg",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Bonus damage added to the weapon's damage.",
+              "guard": "SetBonusDmg"
+            },
+            {
+              "config": "InfiniteDuration",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bInfiniteDuration",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
+              "guard": "SetInfiniteDuration"
+            },
+            {
+              "config": "TickWhenApplied",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bTickWhenApplied",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
+              "guard": "SetTickWhenApplied"
+            },
+            {
+              "config": "CanTickEveryAction",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanTickEveryAction",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
+              "guard": "SetCanTickEveryAction"
+            },
+            {
+              "config": "ConvertTurnsToActions",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bConvertTurnsToActions",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
+              "guard": "SetConvertTurnsToActions"
+            },
+            {
+              "config": "RemoveWhenSourceDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
+              "guard": "SetRemoveWhenSourceDies"
+            },
+            {
+              "config": "RemoveWhenTargetDies",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetDies",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
+              "guard": "SetRemoveWhenTargetDies"
+            },
+            {
+              "config": "RemoveWhenSourceDamaged",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenSourceDamaged",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
+              "guard": "SetRemoveWhenSourceDamaged"
+            },
+            {
+              "config": "RemoveWhenTargetConcealmentBroken",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveWhenTargetConcealmentBroken",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
+              "guard": "SetRemoveWhenTargetConcealmentBroken"
+            },
+            {
+              "config": "PersistThroughTacticalGameEnd",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPersistThroughTacticalGameEnd",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
+              "guard": "SetPersistThroughTacticalGameEnd"
+            },
+            {
+              "config": "IgnorePlayerCheckOnTick",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnorePlayerCheckOnTick",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
+              "guard": "SetIgnorePlayerCheckOnTick"
+            },
+            {
+              "config": "UniqueTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUniqueTarget",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
+              "guard": "SetUniqueTarget"
+            },
+            {
+              "config": "StackOnRefresh",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bStackOnRefresh",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
+              "guard": "SetStackOnRefresh"
+            },
+            {
+              "config": "DupeForSameSourceOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDupeForSameSourceOnly",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
+              "guard": "SetDupeForSameSourceOnly"
+            },
+            {
+              "config": "EffectForcesBleedout",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bEffectForcesBleedout",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
+              "guard": "SetEffectForcesBleedout"
+            },
+            {
+              "config": "DisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
+              "guard": "SetDisplayInUI"
+            },
+            {
+              "config": "DisplayInSpecialDamageMessageUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDisplayInSpecialDamageMessageUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
+              "guard": "SetDisplayInSpecialDamageMessageUI"
+            },
+            {
+              "config": "SourceDisplayInUI",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSourceDisplayInUI",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
+              "guard": "SetSourceDisplayInUI"
+            },
+            {
+              "config": "NumTurns",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iNumTurns",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
+              "guard": "SetNumTurns"
+            },
+            {
+              "config": "InitialShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iInitialShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
+              "guard": "SetInitialShedChance"
+            },
+            {
+              "config": "PerTurnShedChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "iPerTurnShedChance",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
+              "guard": "SetPerTurnShedChance"
+            },
+            {
+              "config": "EffectRank",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectRank",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
+              "guard": "SetEffectRank"
+            },
+            {
+              "config": "EffectHierarchyValue",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EffectHierarchyValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
+              "guard": "SetEffectHierarchyValue"
+            },
+            {
+              "config": "VisionArcDegreesOverride",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "VisionArcDegreesOverride",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
+              "guard": "SetVisionArcDegreesOverride"
+            },
+            {
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_APRounds",
+          "class": "X2AbilityEffectsEditor_ChryssalidBurrowedAttack",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_APRounds",
+          "gameClass": "X2Effect_ChryssalidBurrowedAttack",
           "catchAll": false,
           "fields": [
             {
@@ -18535,7 +25489,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -18545,7 +25499,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -18555,7 +25509,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -18565,7 +25519,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -18575,7 +25529,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -18585,7 +25539,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -18595,7 +25549,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -18605,7 +25559,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -18615,7 +25569,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -18625,7 +25579,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -18635,7 +25589,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -18645,7 +25599,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -18655,7 +25609,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -18665,7 +25619,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -18675,7 +25629,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -18685,7 +25639,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -18695,7 +25649,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -18705,7 +25659,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -18715,7 +25669,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -18729,34 +25683,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "Pierce",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "Pierce",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetPierce"
-            },
-            {
-              "config": "CritChance",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "CritChance",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetCritChance"
-            },
-            {
-              "config": "CritDamage",
+              "config": "NumActions",
               "type": "int",
               "kind": "scalar",
-              "gameField": "CritDamage",
+              "gameField": "NumActions",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetCritDamage"
+              "description": "Number of behavior tree actions the unit runs.",
+              "guard": "SetNumActions"
             },
             {
               "config": "InfiniteDuration",
@@ -18765,7 +25699,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -18775,7 +25709,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -18785,7 +25719,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -18795,7 +25729,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -18805,7 +25739,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -18815,7 +25749,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -18825,7 +25759,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -18835,7 +25769,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -18845,7 +25779,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -18855,7 +25789,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -18865,7 +25799,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -18875,7 +25809,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -18885,7 +25819,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -18895,7 +25829,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -18905,7 +25839,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -18915,7 +25849,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -18925,7 +25859,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -18935,7 +25869,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -18945,7 +25879,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -18955,7 +25889,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -18965,7 +25899,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -18975,7 +25909,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -18985,7 +25919,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -18995,7 +25929,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -19005,7 +25939,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -19015,7 +25949,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -19025,7 +25959,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -19035,7 +25969,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -19045,7 +25979,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -19055,7 +25989,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -19065,7 +25999,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -19075,7 +26009,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -19085,7 +26019,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -19095,7 +26029,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -19105,7 +26039,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -19115,7 +26049,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -19125,7 +26059,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -19135,7 +26069,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -19145,7 +26079,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -19153,9 +26087,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_Aura",
+          "class": "X2AbilityEffectsEditor_ConditionalDamageModifier",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Aura",
+          "gameClass": "X2Effect_ConditionalDamageModifier",
           "catchAll": false,
           "fields": [
             {
@@ -19165,7 +26099,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -19175,7 +26109,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -19185,7 +26119,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -19195,7 +26129,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -19205,7 +26139,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -19215,7 +26149,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -19225,7 +26159,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -19235,7 +26169,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -19245,7 +26179,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -19255,7 +26189,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -19265,7 +26199,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -19275,7 +26209,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -19285,7 +26219,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -19295,7 +26229,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -19305,7 +26239,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -19315,7 +26249,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -19325,7 +26259,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -19335,7 +26269,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -19345,7 +26279,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -19359,15 +26293,53 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "EventsToUpdate",
-              "type": "array<name>",
-              "kind": "namearray",
-              "gameField": "EventsToUpdate",
+              "config": "ModifyOutgoingDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bModifyOutgoingDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "modeField": "EventsToUpdateMode",
-              "modeEnum": "ENameArrayEditMode"
+              "description": "Apply to damage the unit deals.",
+              "guard": "SetModifyOutgoingDamage"
+            },
+            {
+              "config": "ModifyIncomingDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bModifyIncomingDamage",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Apply to damage the unit takes.",
+              "guard": "SetModifyIncomingDamage"
+            },
+            {
+              "config": "DamageModifier",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DamageModifier",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage multiplier; 1.0 leaves the damage unchanged.",
+              "guard": "SetDamageModifier"
+            },
+            {
+              "config": "DamageBonus",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "DamageBonus",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Flat damage added after the multiplier.",
+              "guard": "SetDamageBonus"
+            },
+            {
+              "config": "ApplyDamageModConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": null,
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "X2Effect_ConditionalDamageModifier"
             },
             {
               "config": "InfiniteDuration",
@@ -19376,7 +26348,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -19386,7 +26358,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -19396,7 +26368,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -19406,7 +26378,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -19416,7 +26388,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -19426,7 +26398,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -19436,7 +26408,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -19446,7 +26418,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -19456,7 +26428,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -19466,7 +26438,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -19476,7 +26448,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -19486,7 +26458,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -19496,7 +26468,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -19506,7 +26478,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -19516,7 +26488,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -19526,7 +26498,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -19536,7 +26508,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -19546,7 +26518,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -19556,7 +26528,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -19566,7 +26538,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -19576,7 +26548,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -19586,7 +26558,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -19596,7 +26568,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -19606,7 +26578,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -19616,7 +26588,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -19626,7 +26598,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -19636,7 +26608,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -19646,7 +26618,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -19656,7 +26628,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -19666,7 +26638,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -19676,7 +26648,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -19686,7 +26658,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -19696,7 +26668,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -19706,7 +26678,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -19716,7 +26688,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -19726,7 +26698,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -19736,7 +26708,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -19746,7 +26718,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -19756,17 +26728,22 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "ApplyDamageModConditions",
+              "reason": "array of `X2Condition`"
+            }
+          ]
         },
         {
-          "class": "X2AbilityEffectsEditor_Bewildered",
+          "class": "X2AbilityEffectsEditor_CoveringFire",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Bewildered",
+          "gameClass": "X2Effect_CoveringFire",
           "catchAll": false,
           "fields": [
             {
@@ -19776,7 +26753,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -19786,7 +26763,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -19796,7 +26773,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -19806,7 +26783,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -19816,7 +26793,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -19826,7 +26803,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -19836,7 +26813,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -19846,7 +26823,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -19856,7 +26833,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -19866,7 +26843,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -19876,7 +26853,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -19886,7 +26863,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -19896,7 +26873,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -19906,7 +26883,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -19916,7 +26893,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -19926,7 +26903,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -19936,7 +26913,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -19946,7 +26923,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -19956,7 +26933,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -19970,24 +26947,104 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "DmgMod",
-              "type": "float",
+              "config": "AbilityToActivate",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "DmgMod",
+              "gameField": "AbilityToActivate",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDmgMod"
+              "description": "Ability fired when the covering fire check matches.",
+              "guard": "SetAbilityToActivate"
             },
             {
-              "config": "NumHitsForMod",
+              "config": "GrantActionPoint",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "GrantActionPoint",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Reserve action point given to the covering unit when the check matches.",
+              "guard": "SetGrantActionPoint"
+            },
+            {
+              "config": "MaxPointsPerTurn",
               "type": "int",
               "kind": "scalar",
-              "gameField": "NumHitsForMod",
+              "gameField": "MaxPointsPerTurn",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetNumHitsForMod"
+              "description": "Most times per turn the action point can be granted. 0 or less removes the limit.",
+              "guard": "SetMaxPointsPerTurn"
+            },
+            {
+              "config": "DirectAttackOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bDirectAttackOnly",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Only match when the unit carrying the effect is attacked directly.",
+              "guard": "SetDirectAttackOnly"
+            },
+            {
+              "config": "PreEmptiveFire",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bPreEmptiveFire",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Fire before the attacker's shot resolves instead of after it.",
+              "guard": "SetPreEmptiveFire"
+            },
+            {
+              "config": "OnlyDuringEnemyTurn",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bOnlyDuringEnemyTurn",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Only fire during the enemy turn.",
+              "guard": "SetOnlyDuringEnemyTurn"
+            },
+            {
+              "config": "UseMultiTargets",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseMultiTargets",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Fire the ability at the covering unit itself and hit its multi-targets, instead of retaliating at the attacker.",
+              "guard": "SetUseMultiTargets"
+            },
+            {
+              "config": "OnlyWhenAttackMisses",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bOnlyWhenAttackMisses",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Only fire when the attack missed.",
+              "guard": "SetOnlyWhenAttackMisses"
+            },
+            {
+              "config": "SelfTargeting",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSelfTargeting",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "The fired ability targets the covering unit itself.",
+              "guard": "SetSelfTargeting"
+            },
+            {
+              "config": "ActivationPercentChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ActivationPercentChance",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Percent chance the ability fires when the check matches. 0 always fires.",
+              "guard": "SetActivationPercentChance"
             },
             {
               "config": "InfiniteDuration",
@@ -19996,7 +27053,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -20006,7 +27063,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -20016,7 +27073,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -20026,7 +27083,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -20036,7 +27093,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -20046,7 +27103,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -20056,7 +27113,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -20066,7 +27123,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -20076,7 +27133,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -20086,7 +27143,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -20096,7 +27153,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -20106,7 +27163,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -20116,7 +27173,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -20126,7 +27183,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -20136,7 +27193,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -20146,7 +27203,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -20156,7 +27213,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -20166,7 +27223,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -20176,7 +27233,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -20186,7 +27243,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -20196,7 +27253,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -20206,7 +27263,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -20216,7 +27273,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -20226,7 +27283,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -20236,7 +27293,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -20246,7 +27303,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -20256,7 +27313,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -20266,7 +27323,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -20276,7 +27333,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -20286,7 +27343,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -20296,7 +27353,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -20306,7 +27363,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -20316,7 +27373,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -20326,7 +27383,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -20336,7 +27393,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -20346,7 +27403,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -20356,7 +27413,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -20366,7 +27423,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -20376,7 +27433,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -20384,9 +27441,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_BloodTrail",
+          "class": "X2AbilityEffectsEditor_DamageImmunity",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_BloodTrail",
+          "gameClass": "X2Effect_DamageImmunity",
           "catchAll": false,
           "fields": [
             {
@@ -20396,7 +27453,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -20406,7 +27463,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -20416,7 +27473,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -20426,7 +27483,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -20436,7 +27493,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -20446,7 +27503,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -20456,7 +27513,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -20466,7 +27523,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -20476,7 +27533,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -20486,7 +27543,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -20496,7 +27553,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -20506,7 +27563,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -20516,7 +27573,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -20526,7 +27583,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -20536,7 +27593,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -20546,7 +27603,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -20556,7 +27613,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -20566,7 +27623,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -20576,7 +27633,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -20590,14 +27647,35 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "BonusDamage",
+              "config": "ImmuneTypesAreInclusive",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "ImmueTypesAreInclusive",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "true: immune to the listed damage types only. false: immune to every damage type except the listed ones.",
+              "guard": "SetImmuneTypesAreInclusive"
+            },
+            {
+              "config": "RemoveAfterAttackCount",
               "type": "int",
               "kind": "scalar",
-              "gameField": "BonusDamage",
+              "gameField": "RemoveAfterAttackCount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBonusDamage"
+              "description": "Remove the effect after this many attacks against the unit. 0 keeps it.",
+              "guard": "SetRemoveAfterAttackCount"
+            },
+            {
+              "config": "ImmuneTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "ImmuneTypes",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage types the immunity covers, or excludes when ImmuneTypesAreInclusive is false.",
+              "modeField": "ImmuneTypesMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -20606,7 +27684,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -20616,7 +27694,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -20626,7 +27704,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -20636,7 +27714,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -20646,7 +27724,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -20656,7 +27734,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -20666,7 +27744,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -20676,7 +27754,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -20686,7 +27764,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -20696,7 +27774,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -20706,7 +27784,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -20716,7 +27794,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -20726,7 +27804,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -20736,7 +27814,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -20746,7 +27824,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -20756,7 +27834,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -20766,7 +27844,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -20776,7 +27854,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -20786,7 +27864,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -20796,7 +27874,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -20806,7 +27884,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -20816,7 +27894,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -20826,7 +27904,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -20836,7 +27914,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -20846,7 +27924,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -20856,7 +27934,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -20866,7 +27944,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -20876,7 +27954,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -20886,7 +27964,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -20896,7 +27974,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -20906,7 +27984,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -20916,7 +27994,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -20926,7 +28004,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -20936,7 +28014,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -20946,7 +28024,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -20956,7 +28034,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -20966,7 +28044,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -20976,7 +28054,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -20986,7 +28064,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -20994,9 +28072,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_BonusArmor",
+          "class": "X2AbilityEffectsEditor_DeadeyeDamage",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_BonusArmor",
+          "gameClass": "X2Effect_DeadeyeDamage",
           "catchAll": false,
           "fields": [
             {
@@ -21006,7 +28084,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -21016,7 +28094,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -21026,7 +28104,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -21036,7 +28114,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -21046,7 +28124,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -21056,7 +28134,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -21066,7 +28144,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -21076,7 +28154,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -21086,7 +28164,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -21096,7 +28174,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -21106,7 +28184,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -21116,7 +28194,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -21126,7 +28204,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -21136,7 +28214,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -21146,7 +28224,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -21156,7 +28234,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -21166,7 +28244,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -21176,7 +28254,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -21186,7 +28264,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -21200,14 +28278,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "ArmorMitigationAmount",
-              "type": "int",
+              "config": "DamageMultiplier",
+              "type": "float",
               "kind": "scalar",
-              "gameField": "ArmorMitigationAmount",
+              "gameField": "DamageMultiplier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetArmorMitigationAmount"
+              "description": "Extra damage as a fraction of the damage being dealt.",
+              "guard": "SetDamageMultiplier"
             },
             {
               "config": "InfiniteDuration",
@@ -21216,7 +28294,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -21226,7 +28304,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -21236,7 +28314,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -21246,7 +28324,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -21256,7 +28334,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -21266,7 +28344,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -21276,7 +28354,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -21286,7 +28364,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -21296,7 +28374,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -21306,7 +28384,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -21316,7 +28394,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -21326,7 +28404,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -21336,7 +28414,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -21346,7 +28424,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -21356,7 +28434,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -21366,7 +28444,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -21376,7 +28454,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -21386,7 +28464,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -21396,7 +28474,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -21406,7 +28484,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -21416,7 +28494,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -21426,7 +28504,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -21436,7 +28514,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -21446,7 +28524,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -21456,7 +28534,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -21466,7 +28544,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -21476,7 +28554,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -21486,7 +28564,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -21496,7 +28574,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -21506,7 +28584,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -21516,7 +28594,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -21526,7 +28604,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -21536,7 +28614,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -21546,7 +28624,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -21556,7 +28634,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -21566,7 +28644,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -21576,7 +28654,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -21586,7 +28664,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -21596,7 +28674,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -21604,9 +28682,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_BonusWeaponDamage",
+          "class": "X2AbilityEffectsEditor_DelayedAbilityActivation",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_BonusWeaponDamage",
+          "gameClass": "X2Effect_DelayedAbilityActivation",
           "catchAll": false,
           "fields": [
             {
@@ -21616,7 +28694,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -21626,7 +28704,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -21636,7 +28714,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -21646,7 +28724,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -21656,7 +28734,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -21666,7 +28744,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -21676,7 +28754,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -21686,7 +28764,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -21696,7 +28774,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -21706,7 +28784,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -21716,7 +28794,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -21726,7 +28804,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -21736,7 +28814,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -21746,7 +28824,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -21756,7 +28834,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -21766,7 +28844,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -21776,7 +28854,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -21786,7 +28864,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -21796,7 +28874,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -21810,14 +28888,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "BonusDmg",
-              "type": "int",
+              "config": "TriggerEventName",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "BonusDmg",
+              "gameField": "TriggerEventName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBonusDmg"
+              "description": "Event the effect fires.",
+              "guard": "SetTriggerEventName"
             },
             {
               "config": "InfiniteDuration",
@@ -21826,7 +28904,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -21836,7 +28914,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -21846,7 +28924,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -21856,7 +28934,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -21866,7 +28944,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -21876,7 +28954,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -21886,7 +28964,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -21896,7 +28974,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -21906,7 +28984,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -21916,7 +28994,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -21926,7 +29004,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -21936,7 +29014,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -21946,7 +29024,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -21956,7 +29034,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -21966,7 +29044,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -21976,7 +29054,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -21986,7 +29064,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -21996,7 +29074,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -22006,7 +29084,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -22016,7 +29094,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -22026,7 +29104,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -22036,7 +29114,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -22046,7 +29124,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -22056,7 +29134,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -22066,7 +29144,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -22076,7 +29154,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -22086,7 +29164,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -22096,7 +29174,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -22106,7 +29184,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -22116,7 +29194,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -22126,7 +29204,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -22136,7 +29214,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -22146,7 +29224,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -22156,7 +29234,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -22166,7 +29244,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -22176,7 +29254,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -22186,7 +29264,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -22196,7 +29274,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -22206,7 +29284,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -22214,9 +29292,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_ConditionalDamageModifier",
+          "class": "X2AbilityEffectsEditor_FaceMultiRoundTarget",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_ConditionalDamageModifier",
+          "gameClass": "X2Effect_FaceMultiRoundTarget",
           "catchAll": false,
           "fields": [
             {
@@ -22226,7 +29304,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -22236,7 +29314,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -22246,7 +29324,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -22256,7 +29334,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -22266,7 +29344,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -22276,7 +29354,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -22286,7 +29364,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -22296,7 +29374,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -22306,7 +29384,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -22316,7 +29394,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -22326,7 +29404,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -22336,7 +29414,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -22346,7 +29424,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -22356,7 +29434,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -22366,7 +29444,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -22376,7 +29454,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -22386,7 +29464,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -22396,7 +29474,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -22406,7 +29484,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -22420,53 +29498,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "ModifyOutgoingDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bModifyOutgoingDamage",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetModifyOutgoingDamage"
-            },
-            {
-              "config": "ModifyIncomingDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bModifyIncomingDamage",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetModifyIncomingDamage"
-            },
-            {
-              "config": "DamageModifier",
-              "type": "float",
-              "kind": "scalar",
-              "gameField": "DamageModifier",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDamageModifier"
-            },
-            {
-              "config": "DamageBonus",
-              "type": "int",
+              "config": "TriggerEventName",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "DamageBonus",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDamageBonus"
-            },
-            {
-              "config": "ApplyDamageModConditions",
-              "type": "array<ConditionEdit>",
-              "kind": "nested",
-              "gameField": null,
+              "gameField": "TriggerEventName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "X2Effect_ConditionalDamageModifier"
+              "description": "Event the effect fires.",
+              "guard": "SetTriggerEventName"
             },
             {
               "config": "InfiniteDuration",
@@ -22475,7 +29514,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -22485,7 +29524,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -22495,7 +29534,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -22505,7 +29544,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -22515,7 +29554,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -22525,7 +29564,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -22535,7 +29574,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -22545,7 +29584,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -22555,7 +29594,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -22565,7 +29604,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -22575,7 +29614,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -22585,7 +29624,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -22595,7 +29634,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -22605,7 +29644,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -22615,7 +29654,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -22625,7 +29664,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -22635,7 +29674,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -22645,7 +29684,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -22655,7 +29694,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -22665,7 +29704,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -22675,7 +29714,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -22685,7 +29724,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -22695,7 +29734,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -22705,7 +29744,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -22715,7 +29754,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -22725,7 +29764,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -22735,7 +29774,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -22745,7 +29784,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -22755,7 +29794,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -22765,7 +29804,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -22775,7 +29814,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -22785,7 +29824,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -22795,7 +29834,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -22805,7 +29844,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -22815,7 +29854,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -22825,7 +29864,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -22835,7 +29874,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -22845,7 +29884,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -22855,22 +29894,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": [
-            {
-              "name": "ApplyDamageModConditions",
-              "reason": "array of `X2Condition`"
-            }
-          ]
+          "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_CoveringFire",
+          "class": "X2AbilityEffectsEditor_Fortress",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_CoveringFire",
+          "gameClass": "X2Effect_Fortress",
           "catchAll": false,
           "fields": [
             {
@@ -22880,7 +29914,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -22890,7 +29924,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -22900,7 +29934,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -22910,7 +29944,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -22920,7 +29954,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -22930,7 +29964,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -22940,7 +29974,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -22950,7 +29984,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -22960,7 +29994,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -22970,7 +30004,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -22980,7 +30014,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -22990,7 +30024,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -23000,7 +30034,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -23010,7 +30044,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -23020,7 +30054,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -23030,7 +30064,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -23040,7 +30074,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -23050,7 +30084,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -23060,7 +30094,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -23074,104 +30108,15 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "AbilityToActivate",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "AbilityToActivate",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAbilityToActivate"
-            },
-            {
-              "config": "GrantActionPoint",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "GrantActionPoint",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetGrantActionPoint"
-            },
-            {
-              "config": "MaxPointsPerTurn",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "MaxPointsPerTurn",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetMaxPointsPerTurn"
-            },
-            {
-              "config": "DirectAttackOnly",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bDirectAttackOnly",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDirectAttackOnly"
-            },
-            {
-              "config": "PreEmptiveFire",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bPreEmptiveFire",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetPreEmptiveFire"
-            },
-            {
-              "config": "OnlyDuringEnemyTurn",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bOnlyDuringEnemyTurn",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetOnlyDuringEnemyTurn"
-            },
-            {
-              "config": "UseMultiTargets",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bUseMultiTargets",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetUseMultiTargets"
-            },
-            {
-              "config": "OnlyWhenAttackMisses",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bOnlyWhenAttackMisses",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetOnlyWhenAttackMisses"
-            },
-            {
-              "config": "SelfTargeting",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bSelfTargeting",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetSelfTargeting"
-            },
-            {
-              "config": "ActivationPercentChance",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "ActivationPercentChance",
+              "config": "DamageImmunities",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageImmunities",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetActivationPercentChance"
+              "description": "Damage types the unit is immune to. The game assumes Fire, Acid and Poison are among them.",
+              "modeField": "DamageImmunitiesMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -23180,7 +30125,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -23190,7 +30135,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -23200,7 +30145,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -23210,7 +30155,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -23220,7 +30165,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -23230,7 +30175,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -23240,7 +30185,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -23250,7 +30195,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -23260,7 +30205,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -23270,7 +30215,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -23280,7 +30225,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -23290,7 +30235,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -23300,7 +30245,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -23310,7 +30255,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -23320,7 +30265,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -23330,7 +30275,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -23340,7 +30285,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -23350,7 +30295,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -23360,7 +30305,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -23370,7 +30315,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -23380,7 +30325,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -23390,7 +30335,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -23400,7 +30345,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -23410,7 +30355,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -23420,7 +30365,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -23430,7 +30375,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -23440,7 +30385,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -23450,7 +30395,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -23460,7 +30405,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -23470,7 +30415,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -23480,7 +30425,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -23490,7 +30435,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -23500,7 +30445,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -23510,7 +30455,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -23520,7 +30465,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -23530,7 +30475,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -23540,7 +30485,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -23550,7 +30495,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -23560,7 +30505,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -23568,9 +30513,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_DamageImmunity",
+          "class": "X2AbilityEffectsEditor_GenerateCover",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_DamageImmunity",
+          "gameClass": "X2Effect_GenerateCover",
           "catchAll": false,
           "fields": [
             {
@@ -23580,7 +30525,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -23590,7 +30535,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -23600,7 +30545,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -23610,7 +30555,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -23620,7 +30565,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -23630,7 +30575,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -23640,7 +30585,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -23650,7 +30595,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -23660,7 +30605,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -23670,7 +30615,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -23680,7 +30625,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -23690,7 +30635,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -23700,7 +30645,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -23710,7 +30655,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -23720,7 +30665,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -23730,7 +30675,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -23740,7 +30685,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -23750,7 +30695,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -23760,7 +30705,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -23774,35 +30719,34 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "ImmuneTypesAreInclusive",
-              "type": "bool",
+              "config": "CoverType",
+              "type": "ECoverForceFlag",
               "kind": "scalar",
-              "gameField": "ImmueTypesAreInclusive",
+              "gameField": "CoverType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetImmuneTypesAreInclusive"
+              "description": "Cover the unit provides to others: none, low or high (ECoverForceFlag).",
+              "guard": "SetCoverType"
             },
             {
-              "config": "RemoveAfterAttackCount",
-              "type": "int",
+              "config": "RemoveWhenMoved",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "RemoveAfterAttackCount",
+              "gameField": "bRemoveWhenMoved",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetRemoveAfterAttackCount"
+              "description": "Remove the effect when the unit moves.",
+              "guard": "SetRemoveWhenMoved"
             },
             {
-              "config": "ImmuneTypes",
-              "type": "array<name>",
-              "kind": "namearray",
-              "gameField": "ImmuneTypes",
+              "config": "RemoveOnOtherActivation",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bRemoveOnOtherActivation",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "modeField": "ImmuneTypesMode",
-              "modeEnum": "ENameArrayEditMode"
+              "description": "Remove the effect when the unit activates another ability.",
+              "guard": "SetRemoveOnOtherActivation"
             },
             {
               "config": "InfiniteDuration",
@@ -23811,7 +30755,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -23821,7 +30765,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -23831,7 +30775,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -23841,7 +30785,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -23851,7 +30795,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -23861,7 +30805,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -23871,7 +30815,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -23881,7 +30825,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -23891,7 +30835,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -23901,7 +30845,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -23911,7 +30855,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -23921,7 +30865,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -23931,7 +30875,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -23941,7 +30885,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -23951,7 +30895,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -23961,7 +30905,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -23971,7 +30915,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -23981,7 +30925,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -23991,7 +30935,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -24001,7 +30945,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -24011,7 +30955,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -24021,7 +30965,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -24031,7 +30975,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -24041,7 +30985,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -24051,7 +30995,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -24061,7 +31005,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -24071,7 +31015,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -24081,7 +31025,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -24091,7 +31035,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -24101,7 +31045,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -24111,7 +31055,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -24121,7 +31065,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -24131,7 +31075,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -24141,7 +31085,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -24151,7 +31095,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -24161,7 +31105,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -24171,7 +31115,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -24181,7 +31125,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -24191,7 +31135,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -24199,9 +31143,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_DelayedAbilityActivation",
+          "class": "X2AbilityEffectsEditor_Groundling",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_DelayedAbilityActivation",
+          "gameClass": "X2Effect_Groundling",
           "catchAll": false,
           "fields": [
             {
@@ -24211,7 +31155,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -24221,7 +31165,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -24231,7 +31175,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -24241,7 +31185,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -24251,7 +31195,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -24261,7 +31205,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -24271,7 +31215,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -24281,7 +31225,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -24291,7 +31235,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -24301,7 +31245,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -24311,7 +31255,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -24321,7 +31265,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -24331,7 +31275,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -24341,7 +31285,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -24351,7 +31295,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -24361,7 +31305,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -24371,7 +31315,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -24381,7 +31325,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -24391,7 +31335,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -24405,14 +31349,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "TriggerEventName",
-              "type": "name",
+              "config": "HeightBonus",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "TriggerEventName",
+              "gameField": "HeightBonus",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetTriggerEventName"
+              "description": "Extra aim an attacker gets when it has height advantage over the affected unit.",
+              "guard": "SetHeightBonus"
             },
             {
               "config": "InfiniteDuration",
@@ -24421,7 +31365,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -24431,7 +31375,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -24441,7 +31385,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -24451,7 +31395,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -24461,7 +31405,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -24471,7 +31415,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -24481,7 +31425,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -24491,7 +31435,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -24501,7 +31445,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -24511,7 +31455,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -24521,7 +31465,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -24531,7 +31475,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -24541,7 +31485,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -24551,7 +31495,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -24561,7 +31505,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -24571,7 +31515,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -24581,7 +31525,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -24591,7 +31535,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -24601,7 +31545,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -24611,7 +31555,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -24621,7 +31565,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -24631,7 +31575,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -24641,7 +31585,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -24651,7 +31595,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -24661,7 +31605,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -24671,7 +31615,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -24681,7 +31625,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -24691,7 +31635,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -24701,7 +31645,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -24711,7 +31655,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -24721,7 +31665,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -24731,7 +31675,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -24741,7 +31685,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -24751,7 +31695,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -24761,7 +31705,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -24771,7 +31715,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -24781,7 +31725,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -24791,7 +31735,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -24801,7 +31745,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -24809,9 +31753,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_FaceMultiRoundTarget",
+          "class": "X2AbilityEffectsEditor_Guardian",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_FaceMultiRoundTarget",
+          "gameClass": "X2Effect_Guardian",
           "catchAll": false,
           "fields": [
             {
@@ -24821,7 +31765,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -24831,7 +31775,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -24841,7 +31785,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -24851,7 +31795,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -24861,7 +31805,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -24871,7 +31815,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -24881,7 +31825,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -24891,7 +31835,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -24901,7 +31845,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -24911,7 +31855,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -24921,7 +31865,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -24931,7 +31875,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -24941,7 +31885,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -24951,7 +31895,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -24961,7 +31905,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -24971,7 +31915,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -24981,7 +31925,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -24991,7 +31935,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -25001,7 +31945,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -25015,14 +31959,25 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "TriggerEventName",
-              "type": "name",
+              "config": "AllowedAbilities",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "AllowedAbilities",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Abilities that can trigger the extra reaction shot.",
+              "modeField": "AllowedAbilitiesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "ProcChance",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "TriggerEventName",
+              "gameField": "ProcChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetTriggerEventName"
+              "description": "Percent chance of the extra reaction shot.",
+              "guard": "SetProcChance"
             },
             {
               "config": "InfiniteDuration",
@@ -25031,7 +31986,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -25041,7 +31996,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -25051,7 +32006,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -25061,7 +32016,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -25071,7 +32026,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -25081,7 +32036,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -25091,7 +32046,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -25101,7 +32056,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -25111,7 +32066,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -25121,7 +32076,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -25131,7 +32086,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -25141,7 +32096,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -25151,7 +32106,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -25161,7 +32116,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -25171,7 +32126,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -25181,7 +32136,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -25191,7 +32146,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -25201,7 +32156,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -25211,7 +32166,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -25221,7 +32176,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -25231,7 +32186,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -25241,7 +32196,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -25251,7 +32206,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -25261,7 +32216,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -25271,7 +32226,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -25281,7 +32236,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -25291,7 +32246,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -25301,7 +32256,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -25311,7 +32266,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -25321,7 +32276,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -25331,7 +32286,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -25341,7 +32296,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -25351,7 +32306,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -25361,7 +32316,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -25371,7 +32326,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -25381,7 +32336,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -25391,7 +32346,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -25401,7 +32356,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -25411,7 +32366,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -25419,9 +32374,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_GenerateCover",
+          "class": "X2AbilityEffectsEditor_HoloTarget",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_GenerateCover",
+          "gameClass": "X2Effect_HoloTarget",
           "catchAll": false,
           "fields": [
             {
@@ -25431,7 +32386,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -25441,7 +32396,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -25451,7 +32406,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -25461,7 +32416,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -25471,7 +32426,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -25481,7 +32436,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -25491,7 +32446,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -25501,7 +32456,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -25511,7 +32466,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -25521,7 +32476,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -25531,7 +32486,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -25541,7 +32496,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -25551,7 +32506,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -25561,7 +32516,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -25571,7 +32526,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -25581,7 +32536,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -25591,7 +32546,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -25601,7 +32556,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -25611,7 +32566,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -25625,34 +32580,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "CoverType",
-              "type": "ECoverForceFlag",
-              "kind": "scalar",
-              "gameField": "CoverType",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetCoverType"
-            },
-            {
-              "config": "RemoveWhenMoved",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bRemoveWhenMoved",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetRemoveWhenMoved"
-            },
-            {
-              "config": "RemoveOnOtherActivation",
-              "type": "bool",
+              "config": "HitMod",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "bRemoveOnOtherActivation",
+              "gameField": "HitMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetRemoveOnOtherActivation"
+              "description": "Hit chance modifier applied.",
+              "guard": "SetHitMod"
             },
             {
               "config": "InfiniteDuration",
@@ -25661,7 +32596,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -25671,7 +32606,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -25681,7 +32616,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -25691,7 +32626,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -25701,7 +32636,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -25711,7 +32646,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -25721,7 +32656,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -25731,7 +32666,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -25741,7 +32676,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -25751,7 +32686,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -25761,7 +32696,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -25771,7 +32706,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -25781,7 +32716,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -25791,7 +32726,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -25801,7 +32736,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -25811,7 +32746,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -25821,7 +32756,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -25831,7 +32766,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -25841,7 +32776,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -25851,7 +32786,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -25861,7 +32796,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -25871,7 +32806,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -25881,7 +32816,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -25891,7 +32826,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -25901,7 +32836,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -25911,7 +32846,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -25921,7 +32856,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -25931,7 +32866,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -25941,7 +32876,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -25951,7 +32886,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -25961,7 +32896,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -25971,7 +32906,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -25981,7 +32916,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -25991,7 +32926,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -26001,7 +32936,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -26011,7 +32946,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -26021,7 +32956,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -26031,7 +32966,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -26041,7 +32976,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -26049,9 +32984,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_Groundling",
-          "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Groundling",
+          "class": "X2AbilityEffectsEditor_HolyWarriorDeath",
+          "extends": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+          "gameClass": "X2Effect_HolyWarriorDeath",
           "catchAll": false,
           "fields": [
             {
@@ -26061,7 +32996,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -26071,7 +33006,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -26081,7 +33016,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -26091,7 +33026,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -26101,7 +33036,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -26111,7 +33046,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -26121,7 +33056,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -26131,7 +33066,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -26141,7 +33076,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -26151,7 +33086,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -26161,7 +33096,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -26171,7 +33106,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -26181,7 +33116,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -26191,7 +33126,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -26201,7 +33136,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -26211,7 +33146,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -26221,7 +33156,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -26231,7 +33166,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -26241,7 +33176,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -26255,14 +33190,358 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "HeightBonus",
+              "config": "DelayTimeS",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayTimeS",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Seconds before the death is visualized.",
+              "guard": "SetDelayTimeS"
+            },
+            {
+              "config": "ExplosiveDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bExplosiveDamage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Counts the damage as explosive, so explosive-specific rules such as Blast Padding apply.",
+              "guard": "SetExplosiveDamage"
+            },
+            {
+              "config": "IgnoreBaseDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnoreBaseDamage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Leave out the weapon's base damage; only the effect's own damage and tagged extra damage apply.",
+              "guard": "SetIgnoreBaseDamage"
+            },
+            {
+              "config": "DamageTag",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "DamageTag",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Tag selecting one of the weapon's ExtraDamage entries and the upgrade bonus damage with the same tag.",
+              "guard": "SetDamageTag"
+            },
+            {
+              "config": "AlwaysKillsCivilians",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAlwaysKillsCivilians",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Civilian targets die outright regardless of the damage rolled.",
+              "guard": "SetAlwaysKillsCivilians"
+            },
+            {
+              "config": "ApplyWorldEffectsForEachTargetLocation",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyWorldEffectsForEachTargetLocation",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Apply the ability's world effects at every target location instead of once.",
+              "guard": "SetApplyWorldEffectsForEachTargetLocation"
+            },
+            {
+              "config": "AllowFreeKill",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAllowFreeKill",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Let free-kill weapon upgrades, such as the Repeater, trigger on this damage.",
+              "guard": "SetAllowFreeKill"
+            },
+            {
+              "config": "AllowWeaponUpgrade",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAllowWeaponUpgrade",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Let weapon upgrades add their bonus damage.",
+              "guard": "SetAllowWeaponUpgrade"
+            },
+            {
+              "config": "BypassShields",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBypassShields",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Damage ignores shield HP and goes straight to health.",
+              "guard": "SetBypassShields"
+            },
+            {
+              "config": "IgnoreArmor",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnoreArmor",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Damage ignores armor.",
+              "guard": "SetIgnoreArmor"
+            },
+            {
+              "config": "BypassSustainEffects",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBypassSustainEffects",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Damage ignores sustain effects that would otherwise keep the unit alive.",
+              "guard": "SetBypassSustainEffects"
+            },
+            {
+              "config": "EnvironmentalDamageAmount",
               "type": "int",
               "kind": "scalar",
-              "gameField": "HeightBonus",
+              "gameField": "EnvironmentalDamageAmount",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Environmental damage dealt to terrain and cover.",
+              "guard": "SetEnvironmentalDamageAmount"
+            },
+            {
+              "config": "WeaponDamageValue",
+              "type": "WeaponDamageValueEdit",
+              "kind": "nested",
+              "gameField": "EffectDamageValue",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
+              "description": "Damage the effect adds on its own, on top of the weapon: Damage, Spread, Crit, Pierce, Shred, Rupture, PlusOne, DamageType and Tag."
+            }
+          ],
+          "abstract": false,
+          "notEditable": [
+            {
+              "name": "DoNotKillUnitTypes",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
+        },
+        {
+          "class": "X2AbilityEffectsEditor_HomingMine",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_HomingMine",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "AbilityToTrigger",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilityToTrigger",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetHeightBonus"
+              "description": "Ability fired when the mine goes off.",
+              "guard": "SetAbilityToTrigger"
             },
             {
               "config": "InfiniteDuration",
@@ -26271,7 +33550,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -26281,7 +33560,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -26291,7 +33570,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -26301,7 +33580,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -26311,7 +33590,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -26321,7 +33600,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -26331,7 +33610,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -26341,7 +33620,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -26351,7 +33630,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -26361,7 +33640,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -26371,7 +33650,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -26381,7 +33660,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -26391,7 +33670,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -26401,7 +33680,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -26411,7 +33690,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -26421,7 +33700,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -26431,7 +33710,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -26441,7 +33720,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -26451,7 +33730,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -26461,7 +33740,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -26471,7 +33750,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -26481,7 +33760,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -26491,7 +33770,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -26501,7 +33780,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -26511,7 +33790,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -26521,7 +33800,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -26531,7 +33810,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -26541,7 +33820,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -26551,7 +33830,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -26561,7 +33840,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -26571,7 +33850,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -26581,7 +33860,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -26591,7 +33870,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -26601,7 +33880,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -26611,7 +33890,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -26621,7 +33900,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -26631,7 +33910,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -26641,7 +33920,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -26651,7 +33930,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -26659,9 +33938,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_Guardian",
+          "class": "X2AbilityEffectsEditor_HuntersInstinctDamage",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Guardian",
+          "gameClass": "X2Effect_HuntersInstinctDamage",
           "catchAll": false,
           "fields": [
             {
@@ -26671,7 +33950,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -26681,7 +33960,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -26691,7 +33970,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -26701,7 +33980,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -26711,7 +33990,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -26721,7 +34000,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -26731,7 +34010,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -26741,7 +34020,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -26751,7 +34030,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -26761,7 +34040,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -26771,7 +34050,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -26781,7 +34060,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -26791,7 +34070,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -26801,7 +34080,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -26811,7 +34090,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -26821,7 +34100,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -26831,7 +34110,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -26841,7 +34120,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -26851,7 +34130,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -26865,25 +34144,24 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "AllowedAbilities",
-              "type": "array<name>",
-              "kind": "namearray",
-              "gameField": "AllowedAbilities",
+              "config": "BonusDamage",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "BonusDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "modeField": "AllowedAbilitiesMode",
-              "modeEnum": "ENameArrayEditMode"
+              "description": "Bonus damage added when the effect's condition is met.",
+              "guard": "SetBonusDamage"
             },
             {
-              "config": "ProcChance",
+              "config": "BonusCritChance",
               "type": "int",
               "kind": "scalar",
-              "gameField": "ProcChance",
+              "gameField": "BonusCritChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetProcChance"
+              "description": "Crit chance added when the effect's condition is met.",
+              "guard": "SetBonusCritChance"
             },
             {
               "config": "InfiniteDuration",
@@ -26892,7 +34170,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -26902,7 +34180,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -26912,7 +34190,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -26922,7 +34200,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -26932,7 +34210,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -26942,7 +34220,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -26952,7 +34230,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -26962,7 +34240,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -26972,7 +34250,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -26982,7 +34260,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -26992,7 +34270,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -27002,7 +34280,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -27012,7 +34290,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -27022,7 +34300,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -27032,7 +34310,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -27042,7 +34320,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -27052,7 +34330,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -27062,7 +34340,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -27072,7 +34350,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -27082,7 +34360,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -27092,7 +34370,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -27102,7 +34380,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -27112,7 +34390,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -27122,7 +34400,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -27132,7 +34410,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -27142,7 +34420,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -27152,7 +34430,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -27162,7 +34440,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -27172,7 +34450,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -27182,7 +34460,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -27192,7 +34470,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -27202,7 +34480,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -27212,7 +34490,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -27222,7 +34500,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -27232,7 +34510,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -27242,7 +34520,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -27252,7 +34530,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -27262,7 +34540,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -27272,7 +34550,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -27280,9 +34558,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_HoloTarget",
+          "class": "X2AbilityEffectsEditor_ImmediateAbilityActivation",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_HoloTarget",
+          "gameClass": "X2Effect_ImmediateAbilityActivation",
           "catchAll": false,
           "fields": [
             {
@@ -27292,7 +34570,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -27302,7 +34580,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -27312,7 +34590,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -27322,7 +34600,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -27332,7 +34610,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -27342,7 +34620,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -27352,7 +34630,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -27362,7 +34640,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -27372,7 +34650,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -27382,7 +34660,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -27392,7 +34670,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -27402,7 +34680,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -27412,7 +34690,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -27422,7 +34700,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -27432,7 +34710,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -27442,7 +34720,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -27452,7 +34730,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -27462,7 +34740,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -27472,7 +34750,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -27486,14 +34764,34 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "HitMod",
-              "type": "int",
+              "config": "AbilityName",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "HitMod",
+              "gameField": "AbilityName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetHitMod"
+              "description": "Ability fired by the effect.",
+              "guard": "SetAbilityName"
+            },
+            {
+              "config": "ActivateAbilityOnTarget",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "ActivateAbilityOnTarget",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Find and fire the ability on the target instead of the source.",
+              "guard": "SetActivateAbilityOnTarget"
+            },
+            {
+              "config": "EffectTargetOnly",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "EffectTargetOnly",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Fire only against the effect's target; false fires against every available target.",
+              "guard": "SetEffectTargetOnly"
             },
             {
               "config": "InfiniteDuration",
@@ -27502,7 +34800,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -27512,7 +34810,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -27522,7 +34820,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -27532,7 +34830,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -27542,7 +34840,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -27552,7 +34850,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -27562,7 +34860,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -27572,7 +34870,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -27582,7 +34880,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -27592,7 +34890,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -27602,7 +34900,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -27612,7 +34910,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -27622,7 +34920,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -27632,7 +34930,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -27642,7 +34940,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -27652,7 +34950,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -27662,7 +34960,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -27672,7 +34970,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -27682,7 +34980,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -27692,7 +34990,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -27702,7 +35000,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -27712,7 +35010,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -27722,7 +35020,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -27732,7 +35030,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -27742,7 +35040,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -27752,7 +35050,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -27762,7 +35060,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -27772,7 +35070,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -27782,7 +35080,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -27792,7 +35090,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -27802,7 +35100,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -27812,7 +35110,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -27822,7 +35120,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -27832,7 +35130,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -27842,7 +35140,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -27852,7 +35150,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -27862,7 +35160,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -27872,7 +35170,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -27882,17 +35180,22 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "EventName",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
-          "class": "X2AbilityEffectsEditor_HolyWarriorDeath",
-          "extends": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-          "gameClass": "X2Effect_HolyWarriorDeath",
+          "class": "X2AbilityEffectsEditor_Impatient",
+          "extends": "X2AbilityEffectsEditor_Persistent",
+          "gameClass": "X2Effect_Impatient",
           "catchAll": false,
           "fields": [
             {
@@ -27902,7 +35205,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -27912,7 +35215,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -27922,7 +35225,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -27932,7 +35235,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -27942,7 +35245,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -27952,7 +35255,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -27962,7 +35265,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -27972,7 +35275,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -27982,7 +35285,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -27992,7 +35295,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -28002,7 +35305,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -28012,7 +35315,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -28022,7 +35325,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -28032,7 +35335,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -28042,7 +35345,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -28052,7 +35355,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -28062,7 +35365,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -28072,7 +35375,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -28082,7 +35385,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -28096,353 +35399,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "DelayTimeS",
-              "type": "float",
-              "kind": "scalar",
-              "gameField": "DelayTimeS",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDelayTimeS"
-            },
-            {
-              "config": "ExplosiveDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bExplosiveDamage",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetExplosiveDamage"
-            },
-            {
-              "config": "IgnoreBaseDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bIgnoreBaseDamage",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetIgnoreBaseDamage"
-            },
-            {
-              "config": "DamageTag",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "DamageTag",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetDamageTag"
-            },
-            {
-              "config": "AlwaysKillsCivilians",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAlwaysKillsCivilians",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetAlwaysKillsCivilians"
-            },
-            {
-              "config": "ApplyWorldEffectsForEachTargetLocation",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bApplyWorldEffectsForEachTargetLocation",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetApplyWorldEffectsForEachTargetLocation"
-            },
-            {
-              "config": "AllowFreeKill",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAllowFreeKill",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetAllowFreeKill"
-            },
-            {
-              "config": "AllowWeaponUpgrade",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAllowWeaponUpgrade",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetAllowWeaponUpgrade"
-            },
-            {
-              "config": "BypassShields",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bBypassShields",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetBypassShields"
-            },
-            {
-              "config": "IgnoreArmor",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bIgnoreArmor",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetIgnoreArmor"
-            },
-            {
-              "config": "BypassSustainEffects",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bBypassSustainEffects",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetBypassSustainEffects"
-            },
-            {
-              "config": "EnvironmentalDamageAmount",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "EnvironmentalDamageAmount",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": "",
-              "guard": "SetEnvironmentalDamageAmount"
-            },
-            {
-              "config": "WeaponDamageValue",
-              "type": "WeaponDamageValueEdit",
-              "kind": "nested",
-              "gameField": "EffectDamageValue",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_ApplyWeaponDamage",
-              "description": ""
-            }
-          ],
-          "abstract": false,
-          "notEditable": []
-        },
-        {
-          "class": "X2AbilityEffectsEditor_HomingMine",
-          "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_HomingMine",
-          "catchAll": false,
-          "fields": [
-            {
-              "config": "ApplyOnHit",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bApplyOnHit",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetApplyOnHit"
-            },
-            {
-              "config": "ApplyOnMiss",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bApplyOnMiss",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetApplyOnMiss"
-            },
-            {
-              "config": "ApplyChance",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "ApplyChance",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetApplyChance"
-            },
-            {
-              "config": "ApplyToWorldOnHit",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bApplyToWorldOnHit",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetApplyToWorldOnHit"
-            },
-            {
-              "config": "ApplyToWorldOnMiss",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bApplyToWorldOnMiss",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetApplyToWorldOnMiss"
-            },
-            {
-              "config": "UseSourcePlayerState",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bUseSourcePlayerState",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetUseSourcePlayerState"
-            },
-            {
-              "config": "IsImpairing",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bIsImpairing",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetIsImpairing"
-            },
-            {
-              "config": "IsImpairingMomentarily",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bIsImpairingMomentarily",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetIsImpairingMomentarily"
-            },
-            {
-              "config": "BringRemoveVisualizationForward",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bBringRemoveVisualizationForward",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetBringRemoveVisualizationForward"
-            },
-            {
-              "config": "ShowImmunity",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bShowImmunity",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetShowImmunity"
-            },
-            {
-              "config": "ShowImmunityAnyFailure",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bShowImmunityAnyFailure",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetShowImmunityAnyFailure"
-            },
-            {
-              "config": "AppliesDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAppliesDamage",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetAppliesDamage"
-            },
-            {
-              "config": "CanBeRedirected",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bCanBeRedirected",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetCanBeRedirected"
-            },
-            {
-              "config": "HideDeathWorldMessage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bHideDeathWorldMessage",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetHideDeathWorldMessage"
-            },
-            {
-              "config": "MinStatContestResult",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "MinStatContestResult",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetMinStatContestResult"
-            },
-            {
-              "config": "MaxStatContestResult",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "MaxStatContestResult",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetMaxStatContestResult"
-            },
-            {
-              "config": "DelayVisualizationSec",
+              "config": "DmgMod",
               "type": "float",
               "kind": "scalar",
-              "gameField": "DelayVisualizationSec",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetDelayVisualizationSec"
-            },
-            {
-              "config": "OverrideMissMessage",
-              "type": "string",
-              "kind": "scalar",
-              "gameField": "OverrideMissMessage",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "guard": "SetOverrideMissMessage"
-            },
-            {
-              "config": "DamageTypes",
-              "type": "array<name>",
-              "kind": "namearray",
-              "gameField": "DamageTypes",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
-              "modeField": "DamageTypesMode",
-              "modeEnum": "ENameArrayEditMode"
-            },
-            {
-              "config": "TargetConditions",
-              "type": "array<ConditionEdit>",
-              "kind": "nested",
-              "gameField": "TargetConditions",
-              "origin": "base",
-              "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
-            },
-            {
-              "config": "AbilityToTrigger",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "AbilityToTrigger",
+              "gameField": "DmgMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAbilityToTrigger"
+              "description": "Multiplier applied to the damage when the effect's condition is met.",
+              "guard": "SetDmgMod"
             },
             {
               "config": "InfiniteDuration",
@@ -28451,7 +35415,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -28461,7 +35425,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -28471,7 +35435,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -28481,7 +35445,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -28491,7 +35455,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -28501,7 +35465,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -28511,7 +35475,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -28521,7 +35485,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -28531,7 +35495,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -28541,7 +35505,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -28551,7 +35515,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -28561,7 +35525,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -28571,7 +35535,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -28581,7 +35545,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -28591,7 +35555,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -28601,7 +35565,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -28611,7 +35575,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -28621,7 +35585,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -28631,7 +35595,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -28641,7 +35605,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -28651,7 +35615,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -28661,7 +35625,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -28671,7 +35635,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -28681,7 +35645,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -28691,7 +35655,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -28701,7 +35665,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -28711,7 +35675,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -28721,7 +35685,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -28731,7 +35695,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -28741,7 +35705,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -28751,7 +35715,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -28761,7 +35725,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -28771,7 +35735,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -28781,7 +35745,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -28791,7 +35755,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -28801,7 +35765,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -28811,7 +35775,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -28821,7 +35785,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -28831,7 +35795,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -28839,9 +35803,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_HuntersInstinctDamage",
+          "class": "X2AbilityEffectsEditor_Implacable",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_HuntersInstinctDamage",
+          "gameClass": "X2Effect_Implacable",
           "catchAll": false,
           "fields": [
             {
@@ -28851,7 +35815,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -28861,7 +35825,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -28871,7 +35835,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -28881,7 +35845,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -28891,7 +35855,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -28901,7 +35865,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -28911,7 +35875,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -28921,7 +35885,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -28931,7 +35895,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -28941,7 +35905,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -28951,7 +35915,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -28961,7 +35925,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -28971,7 +35935,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -28981,7 +35945,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -28991,7 +35955,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -29001,7 +35965,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -29011,7 +35975,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -29021,7 +35985,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -29031,7 +35995,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -29045,24 +36009,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "BonusDamage",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "BonusDamage",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBonusDamage"
-            },
-            {
-              "config": "BonusCritChance",
-              "type": "int",
+              "config": "ImplacableThisTurnValue",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "BonusCritChance",
+              "gameField": "ImplacableThisTurnValue",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBonusCritChance"
+              "description": "Unit value that records Implacable already triggered this turn.",
+              "guard": "SetImplacableThisTurnValue"
             },
             {
               "config": "InfiniteDuration",
@@ -29071,7 +36025,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -29081,7 +36035,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -29091,7 +36045,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -29101,7 +36055,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -29111,7 +36065,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -29121,7 +36075,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -29131,7 +36085,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -29141,7 +36095,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -29151,7 +36105,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -29161,7 +36115,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -29171,7 +36125,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -29181,7 +36135,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -29191,7 +36145,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -29201,7 +36155,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -29211,7 +36165,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -29221,7 +36175,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -29231,7 +36185,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -29241,7 +36195,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -29251,7 +36205,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -29261,7 +36215,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -29271,7 +36225,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -29281,7 +36235,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -29291,7 +36245,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -29301,7 +36255,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -29311,7 +36265,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -29321,7 +36275,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -29331,7 +36285,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -29341,7 +36295,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -29351,7 +36305,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -29361,7 +36315,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -29371,7 +36325,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -29381,7 +36335,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -29391,7 +36345,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -29401,7 +36355,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -29411,7 +36365,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -29421,7 +36375,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -29431,7 +36385,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -29441,7 +36395,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -29451,7 +36405,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -29459,9 +36413,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_ImmediateAbilityActivation",
+          "class": "X2AbilityEffectsEditor_LaserSight",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_ImmediateAbilityActivation",
+          "gameClass": "X2Effect_LaserSight",
           "catchAll": false,
           "fields": [
             {
@@ -29471,7 +36425,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -29481,7 +36435,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -29491,7 +36445,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -29501,7 +36455,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -29511,7 +36465,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -29521,7 +36475,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -29531,7 +36485,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -29541,7 +36495,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -29551,7 +36505,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -29561,7 +36515,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -29571,7 +36525,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -29581,7 +36535,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -29591,7 +36545,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -29601,7 +36555,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -29611,7 +36565,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -29621,7 +36575,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -29631,7 +36585,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -29641,7 +36595,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -29651,7 +36605,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -29665,34 +36619,24 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "AbilityName",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "AbilityName",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAbilityName"
-            },
-            {
-              "config": "ActivateAbilityOnTarget",
+              "config": "BenefitFromEmpoweredUpgrades",
               "type": "bool",
               "kind": "scalar",
-              "gameField": "ActivateAbilityOnTarget",
+              "gameField": "bBenefitFromEmpoweredUpgrades",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetActivateAbilityOnTarget"
+              "description": "Increase the crit bonus when XCOM has empowered weapon upgrades. Community Highlander field.",
+              "guard": "SetBenefitFromEmpoweredUpgrades"
             },
             {
-              "config": "EffectTargetOnly",
-              "type": "bool",
+              "config": "CritBonus",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "EffectTargetOnly",
+              "gameField": "CritBonus",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetEffectTargetOnly"
+              "description": "Crit chance added on top of the distance-based bonus.",
+              "guard": "SetCritBonus"
             },
             {
               "config": "InfiniteDuration",
@@ -29701,7 +36645,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -29711,7 +36655,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -29721,7 +36665,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -29731,7 +36675,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -29741,7 +36685,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -29751,7 +36695,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -29761,7 +36705,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -29771,7 +36715,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -29781,7 +36725,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -29791,7 +36735,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -29801,7 +36745,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -29811,7 +36755,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -29821,7 +36765,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -29831,7 +36775,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -29841,7 +36785,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -29851,7 +36795,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -29861,7 +36805,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -29871,7 +36815,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -29881,7 +36825,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -29891,7 +36835,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -29901,7 +36845,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -29911,7 +36855,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -29921,7 +36865,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -29931,7 +36875,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -29941,7 +36885,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -29951,7 +36895,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -29961,7 +36905,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -29971,7 +36915,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -29981,7 +36925,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -29991,7 +36935,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -30001,7 +36945,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -30011,7 +36955,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -30021,7 +36965,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -30031,7 +36975,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -30041,7 +36985,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -30051,7 +36995,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -30061,7 +37005,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -30071,7 +37015,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -30081,17 +37025,22 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "CritBoostArray",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
-          "class": "X2AbilityEffectsEditor_Impatient",
+          "class": "X2AbilityEffectsEditor_MeleeDamageAdjust",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Impatient",
+          "gameClass": "X2Effect_MeleeDamageAdjust",
           "catchAll": false,
           "fields": [
             {
@@ -30101,7 +37050,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -30111,7 +37060,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -30121,7 +37070,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -30131,7 +37080,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -30141,7 +37090,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -30151,7 +37100,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -30161,7 +37110,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -30171,7 +37120,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -30181,7 +37130,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -30191,7 +37140,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -30201,7 +37150,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -30211,7 +37160,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -30221,7 +37170,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -30231,7 +37180,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -30241,7 +37190,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -30251,7 +37200,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -30261,7 +37210,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -30271,7 +37220,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -30281,7 +37230,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -30295,14 +37244,24 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "DmgMod",
-              "type": "float",
+              "config": "DamageMod",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "DmgMod",
+              "gameField": "DamageMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDmgMod"
+              "description": "Damage added to attacks of the melee damage type.",
+              "guard": "SetDamageMod"
+            },
+            {
+              "config": "MeleeDamageTypeName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "MeleeDamageTypeName",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage type that counts as melee for the adjustment.",
+              "guard": "SetMeleeDamageTypeName"
             },
             {
               "config": "InfiniteDuration",
@@ -30311,7 +37270,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -30321,7 +37280,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -30331,7 +37290,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -30341,7 +37300,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -30351,7 +37310,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -30361,7 +37320,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -30371,7 +37330,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -30381,7 +37340,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -30391,7 +37350,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -30401,7 +37360,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -30411,7 +37370,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -30421,7 +37380,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -30431,7 +37390,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -30441,7 +37400,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -30451,7 +37410,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -30461,7 +37420,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -30471,7 +37430,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -30481,7 +37440,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -30491,7 +37450,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -30501,7 +37460,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -30511,7 +37470,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -30521,7 +37480,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -30531,7 +37490,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -30541,7 +37500,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -30551,7 +37510,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -30561,7 +37520,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -30571,7 +37530,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -30581,7 +37540,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -30591,7 +37550,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -30601,7 +37560,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -30611,7 +37570,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -30621,7 +37580,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -30631,7 +37590,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -30641,7 +37600,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -30651,7 +37610,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -30661,7 +37620,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -30671,7 +37630,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -30681,7 +37640,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -30691,7 +37650,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -30699,9 +37658,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_Implacable",
+          "class": "X2AbilityEffectsEditor_MimicBeacon",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Implacable",
+          "gameClass": "X2Effect_MimicBeacon",
           "catchAll": false,
           "fields": [
             {
@@ -30711,7 +37670,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -30721,7 +37680,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -30731,7 +37690,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -30741,7 +37700,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -30751,7 +37710,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -30761,7 +37720,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -30771,7 +37730,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -30781,7 +37740,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -30791,7 +37750,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -30801,7 +37760,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -30811,7 +37770,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -30821,7 +37780,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -30831,7 +37790,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -30841,7 +37800,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -30851,7 +37810,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -30861,7 +37820,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -30871,7 +37830,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -30881,7 +37840,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -30891,7 +37850,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -30905,14 +37864,15 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "ImplacableThisTurnValue",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "ImplacableThisTurnValue",
+              "config": "AbilitiesAllowedToHit",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "ABILITIES_ALLOWED_TO_HIT",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetImplacableThisTurnValue"
+              "description": "Abilities that may still target the mimic beacon.",
+              "modeField": "AbilitiesAllowedToHitMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -30921,7 +37881,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -30931,7 +37891,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -30941,7 +37901,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -30951,7 +37911,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -30961,7 +37921,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -30971,7 +37931,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -30981,7 +37941,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -30991,7 +37951,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -31001,7 +37961,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -31011,7 +37971,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -31021,7 +37981,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -31031,7 +37991,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -31041,7 +38001,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -31051,7 +38011,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -31061,7 +38021,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -31071,7 +38031,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -31081,7 +38041,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -31091,7 +38051,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -31101,7 +38061,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -31111,7 +38071,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -31121,7 +38081,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -31131,7 +38091,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -31141,7 +38101,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -31151,7 +38111,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -31161,7 +38121,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -31171,7 +38131,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -31181,7 +38141,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -31191,7 +38151,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -31201,7 +38161,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -31211,7 +38171,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -31221,7 +38181,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -31231,7 +38191,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -31241,7 +38201,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -31251,7 +38211,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -31261,7 +38221,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -31271,7 +38231,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -31281,7 +38241,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -31291,7 +38251,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -31301,17 +38261,22 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "REMOVE_EFFECT_ANIM_NAME",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
-          "class": "X2AbilityEffectsEditor_LaserSight",
+          "class": "X2AbilityEffectsEditor_MindControl",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_LaserSight",
+          "gameClass": "X2Effect_MindControl",
           "catchAll": false,
           "fields": [
             {
@@ -31321,7 +38286,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -31331,7 +38296,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -31341,7 +38306,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -31351,7 +38316,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -31361,7 +38326,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -31371,7 +38336,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -31381,7 +38346,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -31391,7 +38356,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -31401,7 +38366,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -31411,7 +38376,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -31421,7 +38386,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -31431,7 +38396,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -31441,7 +38406,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -31451,7 +38416,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -31461,7 +38426,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -31471,7 +38436,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -31481,7 +38446,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -31491,7 +38456,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -31501,7 +38466,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -31515,24 +38480,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "BenefitFromEmpoweredUpgrades",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bBenefitFromEmpoweredUpgrades",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBenefitFromEmpoweredUpgrades"
-            },
-            {
-              "config": "CritBonus",
+              "config": "NumTurnsForAI",
               "type": "int",
               "kind": "scalar",
-              "gameField": "CritBonus",
+              "gameField": "iNumTurnsForAI",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetCritBonus"
+              "description": "Turns the control lasts when an AI player is the controller. 0 uses the effect's normal duration.",
+              "guard": "SetNumTurnsForAI"
             },
             {
               "config": "InfiniteDuration",
@@ -31541,7 +38496,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -31551,7 +38506,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -31561,7 +38516,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -31571,7 +38526,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -31581,7 +38536,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -31591,7 +38546,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -31601,7 +38556,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -31611,7 +38566,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -31621,7 +38576,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -31631,7 +38586,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -31641,7 +38596,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -31651,7 +38606,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -31661,7 +38616,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -31671,7 +38626,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -31681,7 +38636,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -31691,7 +38646,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -31701,7 +38656,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -31711,7 +38666,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -31721,7 +38676,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -31731,7 +38686,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -31741,7 +38696,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -31751,7 +38706,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -31761,7 +38716,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -31771,7 +38726,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -31781,7 +38736,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -31791,7 +38746,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -31801,7 +38756,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -31811,7 +38766,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -31821,7 +38776,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -31831,7 +38786,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -31841,7 +38796,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -31851,7 +38806,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -31861,7 +38816,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -31871,7 +38826,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -31881,7 +38836,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -31891,7 +38846,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -31901,7 +38856,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -31911,7 +38866,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -31921,7 +38876,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -31929,9 +38884,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_MeleeDamageAdjust",
+          "class": "X2AbilityEffectsEditor_ModifyReactionFire",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_MeleeDamageAdjust",
+          "gameClass": "X2Effect_ModifyReactionFire",
           "catchAll": false,
           "fields": [
             {
@@ -31941,7 +38896,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -31951,7 +38906,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -31961,7 +38916,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -31971,7 +38926,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -31981,7 +38936,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -31991,7 +38946,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -32001,7 +38956,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -32011,7 +38966,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -32021,7 +38976,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -32031,7 +38986,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -32041,7 +38996,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -32051,7 +39006,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -32061,7 +39016,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -32071,7 +39026,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -32081,7 +39036,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -32091,7 +39046,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -32101,7 +39056,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -32111,7 +39066,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -32121,7 +39076,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -32135,24 +39090,24 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "DamageMod",
-              "type": "int",
+              "config": "AllowCrit",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "DamageMod",
+              "gameField": "bAllowCrit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDamageMod"
+              "description": "Allow reaction fire to crit.",
+              "guard": "SetAllowCrit"
             },
             {
-              "config": "MeleeDamageTypeName",
-              "type": "name",
+              "config": "ReactionModifier",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "MeleeDamageTypeName",
+              "gameField": "ReactionModifier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetMeleeDamageTypeName"
+              "description": "Aim modifier applied to reaction fire.",
+              "guard": "SetReactionModifier"
             },
             {
               "config": "InfiniteDuration",
@@ -32161,7 +39116,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -32171,7 +39126,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -32181,7 +39136,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -32191,7 +39146,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -32201,7 +39156,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -32211,7 +39166,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -32221,7 +39176,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -32231,7 +39186,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -32241,7 +39196,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -32251,7 +39206,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -32261,7 +39216,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -32271,7 +39226,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -32281,7 +39236,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -32291,7 +39246,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -32301,7 +39256,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -32311,7 +39266,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -32321,7 +39276,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -32331,7 +39286,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -32341,7 +39296,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -32351,7 +39306,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -32361,7 +39316,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -32371,7 +39326,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -32381,7 +39336,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -32391,7 +39346,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -32401,7 +39356,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -32411,7 +39366,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -32421,7 +39376,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -32431,7 +39386,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -32441,7 +39396,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -32451,7 +39406,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -32461,7 +39416,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -32471,7 +39426,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -32481,7 +39436,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -32491,7 +39446,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -32501,7 +39456,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -32511,7 +39466,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -32521,7 +39476,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -32531,7 +39486,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -32541,7 +39496,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -32549,9 +39504,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_MindControl",
+          "class": "X2AbilityEffectsEditor_ModifyStatCheckSuccesses",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_MindControl",
+          "gameClass": "X2Effect_ModifyStatCheckSuccesses",
           "catchAll": false,
           "fields": [
             {
@@ -32561,7 +39516,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -32571,7 +39526,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -32581,7 +39536,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -32591,7 +39546,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -32601,7 +39556,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -32611,7 +39566,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -32621,7 +39576,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -32631,7 +39586,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -32641,7 +39596,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -32651,7 +39606,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -32661,7 +39616,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -32671,7 +39626,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -32681,7 +39636,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -32691,7 +39646,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -32701,7 +39656,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -32711,7 +39666,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -32721,7 +39676,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -32731,7 +39686,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -32741,7 +39696,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -32755,14 +39710,15 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "NumTurnsForAI",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "iNumTurnsForAI",
+              "config": "AdditionalSuccessModifiers",
+              "type": "array<AdditionalSuccessModifier>",
+              "kind": "namearray",
+              "gameField": "AdditionalSuccessModifiers",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetNumTurnsForAI"
+              "description": "Bonus successes added to a stat check made by the named ability, when the checked unit is the ability's source. Merge updates the entry with the same AbilityName or adds it.",
+              "modeField": "AdditionalSuccessModifiersMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -32771,7 +39727,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -32781,7 +39737,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -32791,7 +39747,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -32801,7 +39757,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -32811,7 +39767,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -32821,7 +39777,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -32831,7 +39787,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -32841,7 +39797,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -32851,7 +39807,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -32861,7 +39817,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -32871,7 +39827,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -32881,7 +39837,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -32891,7 +39847,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -32901,7 +39857,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -32911,7 +39867,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -32921,7 +39877,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -32931,7 +39887,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -32941,7 +39897,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -32951,7 +39907,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -32961,7 +39917,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -32971,7 +39927,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -32981,7 +39937,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -32991,7 +39947,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -33001,7 +39957,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -33011,7 +39967,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -33021,7 +39977,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -33031,7 +39987,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -33041,7 +39997,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -33051,7 +40007,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -33061,7 +40017,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -33071,7 +40027,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -33081,7 +40037,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -33091,7 +40047,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -33101,7 +40057,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -33111,7 +40067,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -33121,7 +40077,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -33131,7 +40087,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -33141,7 +40097,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -33151,7 +40107,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -33159,9 +40115,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_ModifyReactionFire",
-          "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_ModifyReactionFire",
+          "class": "X2AbilityEffectsEditor_TemplarFocus",
+          "extends": "X2AbilityEffectsEditor_ModifyStats",
+          "gameClass": "X2Effect_TemplarFocus",
           "catchAll": false,
           "fields": [
             {
@@ -33171,7 +40127,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -33181,7 +40137,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -33191,7 +40147,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -33201,7 +40157,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -33211,7 +40167,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -33221,7 +40177,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -33231,7 +40187,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -33241,7 +40197,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -33251,7 +40207,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -33261,7 +40217,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -33271,7 +40227,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -33281,7 +40237,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -33291,7 +40247,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -33301,7 +40257,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -33311,7 +40267,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -33321,7 +40277,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -33331,7 +40287,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -33341,7 +40297,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -33351,7 +40307,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -33365,24 +40321,15 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "AllowCrit",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAllowCrit",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAllowCrit"
-            },
-            {
-              "config": "ReactionModifier",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "ReactionModifier",
+              "config": "FocusLevels",
+              "type": "array<FocusLevelModifiers>",
+              "kind": "namearray",
+              "gameField": "arrFocusModifiers",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetReactionModifier"
+              "description": "One entry per focus level from level 0: the stat changes, armor mitigation and bonus weapon damage granted at that level. Merge overwrites the level at the same position or appends it.",
+              "modeField": "FocusLevelsMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -33391,7 +40338,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -33401,7 +40348,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -33411,7 +40358,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -33421,7 +40368,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -33431,7 +40378,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -33441,7 +40388,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -33451,7 +40398,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -33461,7 +40408,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -33471,7 +40418,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -33481,7 +40428,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -33491,7 +40438,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -33501,7 +40448,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -33511,7 +40458,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -33521,7 +40468,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -33531,7 +40478,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -33541,7 +40488,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -33551,7 +40498,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -33561,7 +40508,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -33571,7 +40518,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -33581,7 +40528,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -33591,7 +40538,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -33601,7 +40548,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -33611,7 +40558,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -33621,7 +40568,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -33631,7 +40578,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -33641,7 +40588,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -33651,7 +40598,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -33661,7 +40608,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -33671,7 +40618,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -33681,7 +40628,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -33691,7 +40638,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -33701,7 +40648,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -33711,7 +40658,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -33721,7 +40668,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -33731,7 +40678,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -33741,7 +40688,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -33751,7 +40698,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -33761,7 +40708,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -33771,12 +40718,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "SpecialDamageName",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_ModifyStats",
@@ -33791,7 +40743,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -33801,7 +40753,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -33811,7 +40763,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -33821,7 +40773,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -33831,7 +40783,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -33841,7 +40793,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -33851,7 +40803,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -33861,7 +40813,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -33871,7 +40823,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -33881,7 +40833,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -33891,7 +40843,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -33901,7 +40853,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -33911,7 +40863,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -33921,7 +40873,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -33931,7 +40883,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -33941,7 +40893,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -33951,7 +40903,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -33961,7 +40913,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -33971,7 +40923,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -33991,7 +40943,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -34001,7 +40953,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -34011,7 +40963,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -34021,7 +40973,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -34031,7 +40983,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -34041,7 +40993,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -34051,7 +41003,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -34061,7 +41013,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -34071,7 +41023,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -34081,7 +41033,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -34091,7 +41043,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -34101,7 +41053,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -34111,7 +41063,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -34121,7 +41073,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -34131,7 +41083,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -34141,7 +41093,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -34151,7 +41103,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -34161,7 +41113,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -34171,7 +41123,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -34181,7 +41133,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -34191,7 +41143,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -34201,7 +41153,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -34211,7 +41163,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -34221,7 +41173,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -34231,7 +41183,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -34241,7 +41193,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -34251,7 +41203,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -34261,7 +41213,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -34271,7 +41223,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -34281,7 +41233,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -34291,7 +41243,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -34301,7 +41253,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -34311,7 +41263,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -34321,7 +41273,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -34331,7 +41283,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -34341,7 +41293,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -34351,7 +41303,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -34361,7 +41313,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -34371,7 +41323,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -34391,7 +41343,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -34401,7 +41353,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -34411,7 +41363,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -34421,7 +41373,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -34431,7 +41383,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -34441,7 +41393,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -34451,7 +41403,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -34461,7 +41413,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -34471,7 +41423,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -34481,7 +41433,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -34491,7 +41443,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -34501,7 +41453,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -34511,7 +41463,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -34521,7 +41473,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -34531,7 +41483,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -34541,7 +41493,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -34551,7 +41503,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -34561,7 +41513,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -34571,7 +41523,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -34591,7 +41543,7 @@
               "gameField": "DmgMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier applied to the damage when the effect's condition is met.",
               "guard": "SetDmgMod"
             },
             {
@@ -34601,7 +41553,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -34611,7 +41563,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -34621,7 +41573,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -34631,7 +41583,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -34641,7 +41593,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -34651,7 +41603,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -34661,7 +41613,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -34671,7 +41623,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -34681,7 +41633,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -34691,7 +41643,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -34701,7 +41653,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -34711,7 +41663,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -34721,7 +41673,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -34731,7 +41683,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -34741,7 +41693,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -34751,7 +41703,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -34761,7 +41713,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -34771,7 +41723,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -34781,7 +41733,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -34791,7 +41743,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -34801,7 +41753,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -34811,7 +41763,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -34821,7 +41773,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -34831,7 +41783,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -34841,7 +41793,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -34851,7 +41803,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -34861,7 +41813,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -34871,7 +41823,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -34881,7 +41833,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -34891,7 +41843,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -34901,7 +41853,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -34911,7 +41863,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -34921,7 +41873,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -34931,7 +41883,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -34941,7 +41893,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -34951,7 +41903,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -34961,7 +41913,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -34971,7 +41923,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -34981,7 +41933,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -35001,7 +41953,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -35011,7 +41963,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -35021,7 +41973,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -35031,7 +41983,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -35041,7 +41993,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -35051,7 +42003,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -35061,7 +42013,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -35071,7 +42023,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -35081,7 +42033,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -35091,7 +42043,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -35101,7 +42053,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -35111,7 +42063,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -35121,7 +42073,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -35131,7 +42083,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -35141,7 +42093,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -35151,7 +42103,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -35161,7 +42113,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -35171,7 +42123,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -35181,7 +42133,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -35201,7 +42153,7 @@
               "gameField": "ArmorPierce",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Armor pierced.",
               "guard": "SetArmorPierce"
             },
             {
@@ -35211,7 +42163,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -35221,7 +42173,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -35231,7 +42183,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -35241,7 +42193,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -35251,7 +42203,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -35261,7 +42213,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -35271,7 +42223,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -35281,7 +42233,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -35291,7 +42243,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -35301,7 +42253,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -35311,7 +42263,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -35321,7 +42273,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -35331,7 +42283,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -35341,7 +42293,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -35351,7 +42303,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -35361,7 +42313,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -35371,7 +42323,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -35381,7 +42333,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -35391,7 +42343,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -35401,7 +42353,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -35411,7 +42363,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -35421,7 +42373,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -35431,7 +42383,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -35441,7 +42393,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -35451,7 +42403,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -35461,7 +42413,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -35471,7 +42423,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -35481,7 +42433,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -35491,7 +42443,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -35501,7 +42453,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -35511,7 +42463,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -35521,7 +42473,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -35531,7 +42483,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -35541,7 +42493,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -35551,7 +42503,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -35561,7 +42513,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -35571,7 +42523,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -35581,7 +42533,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -35591,7 +42543,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -35611,7 +42563,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -35621,7 +42573,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -35631,7 +42583,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -35641,7 +42593,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -35651,7 +42603,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -35661,7 +42613,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -35671,7 +42623,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -35681,7 +42633,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -35691,7 +42643,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -35701,7 +42653,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -35711,7 +42663,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -35721,7 +42673,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -35731,7 +42683,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -35741,7 +42693,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -35751,7 +42703,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -35761,7 +42713,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -35771,7 +42723,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -35781,7 +42733,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -35791,7 +42743,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -35811,7 +42763,7 @@
               "gameField": "DmgMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier applied to the damage when the effect's condition is met.",
               "guard": "SetDmgMod"
             },
             {
@@ -35821,7 +42773,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -35831,7 +42783,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -35841,7 +42793,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -35851,7 +42803,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -35861,7 +42813,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -35871,7 +42823,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -35881,7 +42833,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -35891,7 +42843,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -35901,7 +42853,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -35911,7 +42863,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -35921,7 +42873,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -35931,7 +42883,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -35941,7 +42893,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -35951,7 +42903,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -35961,7 +42913,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -35971,7 +42923,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -35981,7 +42933,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -35991,7 +42943,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -36001,7 +42953,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -36011,7 +42963,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -36021,7 +42973,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -36031,7 +42983,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -36041,7 +42993,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -36051,7 +43003,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -36061,7 +43013,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -36071,7 +43023,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -36081,7 +43033,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -36091,7 +43043,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -36101,7 +43053,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -36111,7 +43063,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -36121,7 +43073,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -36131,7 +43083,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -36141,7 +43093,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -36151,7 +43103,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -36161,7 +43113,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -36171,7 +43123,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -36181,7 +43133,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -36191,7 +43143,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -36201,7 +43153,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -36209,9 +43161,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_OverrideDeathAnimOnLoad",
+          "class": "X2AbilityEffectsEditor_OverrideDeathAction",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_OverrideDeathAnimOnLoad",
+          "gameClass": "X2Effect_OverrideDeathAction",
           "catchAll": false,
           "fields": [
             {
@@ -36221,7 +43173,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -36231,7 +43183,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -36241,7 +43193,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -36251,7 +43203,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -36261,7 +43213,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -36271,7 +43223,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -36281,7 +43233,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -36291,7 +43243,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -36301,7 +43253,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -36311,7 +43263,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -36321,7 +43273,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -36331,7 +43283,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -36341,7 +43293,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -36351,7 +43303,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -36361,7 +43313,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -36371,7 +43323,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -36381,7 +43333,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -36391,7 +43343,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -36401,7 +43353,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -36415,14 +43367,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "OverrideAnimNameOnLoad",
-              "type": "name",
+              "config": "DeathActionClass",
+              "type": "string",
               "kind": "scalar",
-              "gameField": "OverrideAnimNameOnLoad",
+              "gameField": "DeathActionClass",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetOverrideAnimNameOnLoad"
+              "description": "Qualified class path of the X2Action that replaces the normal death visualization, e.g. XComGame.X2Action_ExplodingUnitDeathAction. Empty removes the override.",
+              "guard": "SetDeathActionClass"
             },
             {
               "config": "InfiniteDuration",
@@ -36431,7 +43383,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -36441,7 +43393,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -36451,7 +43403,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -36461,7 +43413,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -36471,7 +43423,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -36481,7 +43433,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -36491,7 +43443,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -36501,7 +43453,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -36511,7 +43463,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -36521,7 +43473,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -36531,7 +43483,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -36541,7 +43493,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -36551,7 +43503,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -36561,7 +43513,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -36571,7 +43523,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -36581,7 +43533,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -36591,7 +43543,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -36601,7 +43553,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -36611,7 +43563,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -36621,7 +43573,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -36631,7 +43583,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -36641,7 +43593,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -36651,7 +43603,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -36661,7 +43613,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -36671,7 +43623,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -36681,7 +43633,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -36691,7 +43643,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -36701,7 +43653,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -36711,7 +43663,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -36721,7 +43673,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -36731,7 +43683,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -36741,7 +43693,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -36751,7 +43703,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -36761,7 +43713,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -36771,7 +43723,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -36781,7 +43733,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -36791,7 +43743,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -36801,7 +43753,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -36811,7 +43763,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -36819,9 +43771,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_PaleHorse",
+          "class": "X2AbilityEffectsEditor_OverrideDeathAnimOnLoad",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_PaleHorse",
+          "gameClass": "X2Effect_OverrideDeathAnimOnLoad",
           "catchAll": false,
           "fields": [
             {
@@ -36831,7 +43783,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -36841,7 +43793,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -36851,7 +43803,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -36861,7 +43813,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -36871,7 +43823,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -36881,7 +43833,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -36891,7 +43843,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -36901,7 +43853,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -36911,7 +43863,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -36921,7 +43873,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -36931,7 +43883,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -36941,7 +43893,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -36951,7 +43903,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -36961,7 +43913,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -36971,7 +43923,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -36981,7 +43933,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -36991,7 +43943,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -37001,7 +43953,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -37011,7 +43963,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -37025,24 +43977,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "CritBoostPerKill",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "CritBoostPerKill",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetCritBoostPerKill"
-            },
-            {
-              "config": "MaxCritBoost",
-              "type": "int",
+              "config": "OverrideAnimNameOnLoad",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "MaxCritBoost",
+              "gameField": "OverrideAnimNameOnLoad",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetMaxCritBoost"
+              "description": "Death animation shown for the unit when a save is loaded.",
+              "guard": "SetOverrideAnimNameOnLoad"
             },
             {
               "config": "InfiniteDuration",
@@ -37051,7 +43993,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -37061,7 +44003,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -37071,7 +44013,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -37081,7 +44023,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -37091,7 +44033,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -37101,7 +44043,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -37111,7 +44053,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -37121,7 +44063,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -37131,7 +44073,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -37141,7 +44083,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -37151,7 +44093,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -37161,7 +44103,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -37171,7 +44113,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -37181,7 +44123,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -37191,7 +44133,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -37201,7 +44143,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -37211,7 +44153,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -37221,7 +44163,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -37231,7 +44173,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -37241,7 +44183,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -37251,7 +44193,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -37261,7 +44203,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -37271,7 +44213,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -37281,7 +44223,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -37291,7 +44233,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -37301,7 +44243,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -37311,7 +44253,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -37321,7 +44263,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -37331,7 +44273,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -37341,7 +44283,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -37351,7 +44293,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -37361,7 +44303,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -37371,7 +44313,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -37381,7 +44323,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -37391,7 +44333,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -37401,7 +44343,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -37411,7 +44353,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -37421,7 +44363,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -37431,7 +44373,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -37439,9 +44381,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_PersistentSquadViewer",
+          "class": "X2AbilityEffectsEditor_PaleHorse",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_PersistentSquadViewer",
+          "gameClass": "X2Effect_PaleHorse",
           "catchAll": false,
           "fields": [
             {
@@ -37451,7 +44393,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -37461,7 +44403,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -37471,7 +44413,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -37481,7 +44423,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -37491,7 +44433,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -37501,7 +44443,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -37511,7 +44453,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -37521,7 +44463,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -37531,7 +44473,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -37541,7 +44483,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -37551,7 +44493,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -37561,7 +44503,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -37571,7 +44513,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -37581,7 +44523,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -37591,7 +44533,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -37601,7 +44543,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -37611,7 +44553,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -37621,7 +44563,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -37631,7 +44573,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -37645,34 +44587,24 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "UseWeaponRadius",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bUseWeaponRadius",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetUseWeaponRadius"
-            },
-            {
-              "config": "ViewRadius",
-              "type": "float",
+              "config": "CritBoostPerKill",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "ViewRadius",
+              "gameField": "CritBoostPerKill",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetViewRadius"
+              "description": "Crit chance gained per kill.",
+              "guard": "SetCritBoostPerKill"
             },
             {
-              "config": "UseSourceLocation",
-              "type": "bool",
+              "config": "MaxCritBoost",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "bUseSourceLocation",
+              "gameField": "MaxCritBoost",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetUseSourceLocation"
+              "description": "Cap on the accumulated crit chance.",
+              "guard": "SetMaxCritBoost"
             },
             {
               "config": "InfiniteDuration",
@@ -37681,7 +44613,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -37691,7 +44623,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -37701,7 +44633,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -37711,7 +44643,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -37721,7 +44653,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -37731,7 +44663,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -37741,7 +44673,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -37751,7 +44683,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -37761,7 +44693,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -37771,7 +44703,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -37781,7 +44713,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -37791,7 +44723,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -37801,7 +44733,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -37811,7 +44743,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -37821,7 +44753,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -37831,7 +44763,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -37841,7 +44773,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -37851,7 +44783,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -37861,7 +44793,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -37871,7 +44803,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -37881,7 +44813,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -37891,7 +44823,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -37901,7 +44833,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -37911,7 +44843,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -37921,7 +44853,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -37931,7 +44863,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -37941,7 +44873,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -37951,7 +44883,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -37961,7 +44893,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -37971,7 +44903,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -37981,7 +44913,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -37991,7 +44923,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -38001,7 +44933,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -38011,7 +44943,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -38021,7 +44953,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -38031,7 +44963,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -38041,7 +44973,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -38051,7 +44983,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -38061,7 +44993,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -38069,9 +45001,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_PersistentTraversalChange",
+          "class": "X2AbilityEffectsEditor_PersistentSquadViewer",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_PersistentTraversalChange",
+          "gameClass": "X2Effect_PersistentSquadViewer",
           "catchAll": false,
           "fields": [
             {
@@ -38081,7 +45013,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -38091,7 +45023,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -38101,7 +45033,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -38111,7 +45043,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -38121,7 +45053,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -38131,7 +45063,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -38141,7 +45073,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -38151,7 +45083,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -38161,7 +45093,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -38171,7 +45103,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -38181,7 +45113,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -38191,7 +45123,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -38201,7 +45133,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -38211,7 +45143,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -38221,7 +45153,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -38231,7 +45163,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -38241,7 +45173,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -38251,7 +45183,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -38261,7 +45193,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -38275,15 +45207,34 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "TraversalChanges",
-              "type": "array<TraversalChange>",
-              "kind": "namearray",
-              "gameField": "aTraversalChanges",
+              "config": "UseWeaponRadius",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseWeaponRadius",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "modeField": "TraversalChangesMode",
-              "modeEnum": "ENameArrayEditMode"
+              "description": "Use the source weapon's radius as the sight radius. Requires a source weapon.",
+              "guard": "SetUseWeaponRadius"
+            },
+            {
+              "config": "ViewRadius",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "ViewRadius",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Sight radius of the viewer.",
+              "guard": "SetViewRadius"
+            },
+            {
+              "config": "UseSourceLocation",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourceLocation",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Place the viewer at the source's location rather than the target's.",
+              "guard": "SetUseSourceLocation"
             },
             {
               "config": "InfiniteDuration",
@@ -38292,7 +45243,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -38302,7 +45253,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -38312,7 +45263,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -38322,7 +45273,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -38332,7 +45283,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -38342,7 +45293,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -38352,7 +45303,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -38362,7 +45313,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -38372,7 +45323,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -38382,7 +45333,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -38392,7 +45343,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -38402,7 +45353,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -38412,7 +45363,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -38422,7 +45373,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -38432,7 +45383,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -38442,7 +45393,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -38452,7 +45403,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -38462,7 +45413,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -38472,7 +45423,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -38482,7 +45433,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -38492,7 +45443,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -38502,7 +45453,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -38512,7 +45463,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -38522,7 +45473,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -38532,7 +45483,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -38542,7 +45493,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -38552,7 +45503,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -38562,7 +45513,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -38572,7 +45523,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -38582,7 +45533,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -38592,7 +45543,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -38602,7 +45553,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -38612,7 +45563,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -38622,7 +45573,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -38632,7 +45583,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -38642,7 +45593,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -38652,7 +45603,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -38662,7 +45613,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -38672,7 +45623,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -38680,9 +45631,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_PersistentVoidConduit",
+          "class": "X2AbilityEffectsEditor_PersistentTraversalChange",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_PersistentVoidConduit",
+          "gameClass": "X2Effect_PersistentTraversalChange",
           "catchAll": false,
           "fields": [
             {
@@ -38692,7 +45643,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -38702,7 +45653,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -38712,7 +45663,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -38722,7 +45673,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -38732,7 +45683,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -38742,7 +45693,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -38752,7 +45703,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -38762,7 +45713,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -38772,7 +45723,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -38782,7 +45733,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -38792,7 +45743,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -38802,7 +45753,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -38812,7 +45763,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -38822,7 +45773,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -38832,7 +45783,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -38842,7 +45793,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -38852,7 +45803,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -38862,7 +45813,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -38872,7 +45823,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -38886,14 +45837,15 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "InitialDamage",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "InitialDamage",
+              "config": "TraversalChanges",
+              "type": "array<TraversalChange>",
+              "kind": "namearray",
+              "gameField": "aTraversalChanges",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetInitialDamage"
+              "description": "Traversal types switched on or off while the effect lasts, merged by Traversal.",
+              "modeField": "TraversalChangesMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -38902,7 +45854,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -38912,7 +45864,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -38922,7 +45874,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -38932,7 +45884,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -38942,7 +45894,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -38952,7 +45904,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -38962,7 +45914,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -38972,7 +45924,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -38982,7 +45934,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -38992,7 +45944,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -39002,7 +45954,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -39012,7 +45964,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -39022,7 +45974,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -39032,7 +45984,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -39042,7 +45994,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -39052,7 +46004,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -39062,7 +46014,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -39072,7 +46024,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -39082,7 +46034,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -39092,7 +46044,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -39102,7 +46054,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -39112,7 +46064,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -39122,7 +46074,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -39132,7 +46084,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -39142,7 +46094,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -39152,7 +46104,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -39162,7 +46114,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -39172,7 +46124,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -39182,7 +46134,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -39192,7 +46144,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -39202,7 +46154,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -39212,7 +46164,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -39222,7 +46174,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -39232,7 +46184,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -39242,7 +46194,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -39252,7 +46204,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -39262,7 +46214,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -39272,7 +46224,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -39282,7 +46234,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -39290,9 +46242,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_Possessed",
+          "class": "X2AbilityEffectsEditor_PersistentVoidConduit",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Possessed",
+          "gameClass": "X2Effect_PersistentVoidConduit",
           "catchAll": false,
           "fields": [
             {
@@ -39302,7 +46254,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -39312,7 +46264,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -39322,7 +46274,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -39332,7 +46284,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -39342,7 +46294,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -39352,7 +46304,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -39362,7 +46314,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -39372,7 +46324,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -39382,7 +46334,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -39392,7 +46344,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -39402,7 +46354,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -39412,7 +46364,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -39422,7 +46374,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -39432,7 +46384,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -39442,7 +46394,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -39452,7 +46404,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -39462,7 +46414,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -39472,7 +46424,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -39482,7 +46434,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -39496,14 +46448,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "WeaponTemplateName",
-              "type": "name",
+              "config": "InitialDamage",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "WeaponTemplateName",
+              "gameField": "InitialDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetWeaponTemplateName"
+              "description": "Damage dealt when the effect is applied.",
+              "guard": "SetInitialDamage"
             },
             {
               "config": "InfiniteDuration",
@@ -39512,7 +46464,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -39522,7 +46474,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -39532,7 +46484,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -39542,7 +46494,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -39552,7 +46504,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -39562,7 +46514,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -39572,7 +46524,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -39582,7 +46534,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -39592,7 +46544,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -39602,7 +46554,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -39612,7 +46564,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -39622,7 +46574,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -39632,7 +46584,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -39642,7 +46594,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -39652,7 +46604,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -39662,7 +46614,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -39672,7 +46624,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -39682,7 +46634,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -39692,7 +46644,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -39702,7 +46654,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -39712,7 +46664,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -39722,7 +46674,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -39732,7 +46684,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -39742,7 +46694,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -39752,7 +46704,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -39762,7 +46714,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -39772,7 +46724,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -39782,7 +46734,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -39792,7 +46744,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -39802,7 +46754,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -39812,7 +46764,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -39822,7 +46774,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -39832,7 +46784,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -39842,7 +46794,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -39852,7 +46804,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -39862,7 +46814,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -39872,7 +46824,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -39882,7 +46834,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -39892,17 +46844,26 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "VoidConduitActionsLeft",
+              "reason": "private/protected"
+            },
+            {
+              "name": "StolenActionsThisTick",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
-          "class": "X2AbilityEffectsEditor_Reaper",
+          "class": "X2AbilityEffectsEditor_Possessed",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_Reaper",
+          "gameClass": "X2Effect_Possessed",
           "catchAll": false,
           "fields": [
             {
@@ -39912,7 +46873,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -39922,7 +46883,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -39932,7 +46893,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -39942,7 +46903,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -39952,7 +46913,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -39962,7 +46923,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -39972,7 +46933,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -39982,7 +46943,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -39992,7 +46953,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -40002,7 +46963,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -40012,7 +46973,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -40022,7 +46983,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -40032,7 +46993,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -40042,7 +47003,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -40052,7 +47013,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -40062,7 +47023,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -40072,7 +47033,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -40082,7 +47043,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -40092,7 +47053,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -40106,24 +47067,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "ReaperActivatedName",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "ReaperActivatedName",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetReaperActivatedName"
-            },
-            {
-              "config": "ReaperKillName",
+              "config": "WeaponTemplateName",
               "type": "name",
               "kind": "scalar",
-              "gameField": "ReaperKillName",
+              "gameField": "WeaponTemplateName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetReaperKillName"
+              "description": "Item template equipped on the possessed unit.",
+              "guard": "SetWeaponTemplateName"
             },
             {
               "config": "InfiniteDuration",
@@ -40132,7 +47083,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -40142,7 +47093,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -40152,7 +47103,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -40162,7 +47113,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -40172,7 +47123,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -40182,7 +47133,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -40192,7 +47143,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -40202,7 +47153,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -40212,7 +47163,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -40222,7 +47173,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -40232,7 +47183,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -40242,7 +47193,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -40252,7 +47203,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -40262,7 +47213,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -40272,7 +47223,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -40282,7 +47233,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -40292,7 +47243,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -40302,7 +47253,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -40312,7 +47263,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -40322,7 +47273,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -40332,7 +47283,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -40342,7 +47293,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -40352,7 +47303,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -40362,7 +47313,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -40372,7 +47323,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -40382,7 +47333,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -40392,7 +47343,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -40402,7 +47353,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -40412,7 +47363,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -40422,7 +47373,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -40432,7 +47383,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -40442,7 +47393,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -40452,7 +47403,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -40462,7 +47413,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -40472,7 +47423,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -40482,7 +47433,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -40492,7 +47443,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -40502,7 +47453,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -40512,12 +47463,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "FlyoverText",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_Regeneration",
@@ -40532,7 +47488,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -40542,7 +47498,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -40552,7 +47508,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -40562,7 +47518,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -40572,7 +47528,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -40582,7 +47538,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -40592,7 +47548,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -40602,7 +47558,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -40612,7 +47568,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -40622,7 +47578,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -40632,7 +47588,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -40642,7 +47598,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -40652,7 +47608,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -40662,7 +47618,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -40672,7 +47628,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -40682,7 +47638,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -40692,7 +47648,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -40702,7 +47658,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -40712,7 +47668,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -40732,7 +47688,7 @@
               "gameField": "HealAmount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "HP healed per tick.",
               "guard": "SetHealAmount"
             },
             {
@@ -40742,7 +47698,7 @@
               "gameField": "MaxHealAmount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Total HP the effect may heal, tracked in HealthRegeneratedName. 0 removes the cap.",
               "guard": "SetMaxHealAmount"
             },
             {
@@ -40752,7 +47708,7 @@
               "gameField": "HealthRegeneratedName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value that accumulates the HP healed so far, for the MaxHealAmount cap.",
               "guard": "SetHealthRegeneratedName"
             },
             {
@@ -40762,7 +47718,7 @@
               "gameField": "EventToTriggerOnHeal",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Event fired after each heal.",
               "guard": "SetEventToTriggerOnHeal"
             },
             {
@@ -40772,7 +47728,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -40782,7 +47738,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -40792,7 +47748,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -40802,7 +47758,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -40812,7 +47768,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -40822,7 +47778,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -40832,7 +47788,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -40842,7 +47798,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -40852,7 +47808,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -40862,7 +47818,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -40872,7 +47828,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -40882,7 +47838,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -40892,7 +47848,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -40902,7 +47858,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -40912,7 +47868,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -40922,7 +47878,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -40932,7 +47888,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -40942,7 +47898,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -40952,7 +47908,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -40962,7 +47918,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -40972,7 +47928,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -40982,7 +47938,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -40992,7 +47948,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -41002,7 +47958,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -41012,7 +47968,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -41022,7 +47978,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -41032,7 +47988,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -41042,7 +47998,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -41052,7 +48008,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -41062,7 +48018,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -41072,7 +48028,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -41082,7 +48038,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -41092,7 +48048,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -41102,7 +48058,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -41112,7 +48068,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -41122,7 +48078,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -41132,7 +48088,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -41142,7 +48098,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -41152,12 +48108,17 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "HealedMessage",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_RemoveEffectsByDamageType",
@@ -41172,7 +48133,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -41182,7 +48143,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -41192,7 +48153,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -41202,7 +48163,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -41212,7 +48173,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -41222,7 +48183,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -41232,7 +48193,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -41242,7 +48203,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -41252,7 +48213,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -41262,7 +48223,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -41272,7 +48233,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -41282,7 +48243,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -41292,7 +48253,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -41302,7 +48263,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -41312,7 +48273,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -41322,7 +48283,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -41332,7 +48293,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -41342,7 +48303,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -41352,7 +48313,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -41372,7 +48333,7 @@
               "gameField": "DamageTypesToRemove",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effects carrying any of these damage types are removed.",
               "modeField": "DamageTypesToRemoveMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -41383,7 +48344,7 @@
               "gameField": "bCleanse",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_RemoveEffects",
-              "description": "",
+              "description": "Remove the effects as a cleanse, so whatever they do on wearing off does not trigger.",
               "guard": "SetCleanse"
             },
             {
@@ -41393,7 +48354,7 @@
               "gameField": "bCheckSource",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_RemoveEffects",
-              "description": "",
+              "description": "Match effects whose source is this effect's target, instead of effects whose target it is.",
               "guard": "SetCheckSource"
             },
             {
@@ -41403,7 +48364,7 @@
               "gameField": "bDoNotVisualize",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_RemoveEffects",
-              "description": "",
+              "description": "Skip the removal visualization, for when another RemoveEffects on the ability already shows it.",
               "guard": "SetDoNotVisualize"
             },
             {
@@ -41413,7 +48374,7 @@
               "gameField": "EffectNamesToRemove",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_RemoveEffects",
-              "description": "",
+              "description": "Effect names removed from the target.",
               "modeField": "EffectNamesToRemoveMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -41434,7 +48395,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -41444,7 +48405,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -41454,7 +48415,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -41464,7 +48425,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -41474,7 +48435,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -41484,7 +48445,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -41494,7 +48455,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -41504,7 +48465,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -41514,7 +48475,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -41524,7 +48485,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -41534,7 +48495,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -41544,7 +48505,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -41554,7 +48515,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -41564,7 +48525,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -41574,7 +48535,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -41584,7 +48545,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -41594,7 +48555,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -41604,7 +48565,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -41614,7 +48575,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -41634,7 +48595,7 @@
               "gameField": "UseAllPointsWithAbilities",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Abilities that, when the unit has any of them, reserve as many points as were spent instead of NumPoints.",
               "modeField": "UseAllPointsWithAbilitiesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -41645,7 +48606,7 @@
               "gameField": "ReserveType",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_ReserveActionPoints",
-              "description": "",
+              "description": "Type of action point reserved.",
               "guard": "SetReserveType"
             },
             {
@@ -41655,7 +48616,7 @@
               "gameField": "NumPoints",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_ReserveActionPoints",
-              "description": "",
+              "description": "Number of action points reserved.",
               "guard": "SetNumPoints"
             }
           ],
@@ -41675,7 +48636,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -41685,7 +48646,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -41695,7 +48656,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -41705,7 +48666,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -41715,7 +48676,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -41725,7 +48686,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -41735,7 +48696,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -41745,7 +48706,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -41755,7 +48716,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -41765,7 +48726,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -41775,7 +48736,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -41785,7 +48746,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -41795,7 +48756,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -41805,7 +48766,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -41815,7 +48776,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -41825,7 +48786,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -41835,7 +48796,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -41845,7 +48806,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -41855,7 +48816,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -41875,7 +48836,7 @@
               "gameField": "NumActions",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Number of behavior tree actions the unit runs.",
               "guard": "SetNumActions"
             },
             {
@@ -41885,7 +48846,7 @@
               "gameField": "BehaviorTreeName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Behavior tree run on the unit.",
               "guard": "SetBehaviorTreeName"
             },
             {
@@ -41895,7 +48856,7 @@
               "gameField": "bInitFromPlayer",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reset the behavior tree variables on each run as if the player turn were starting.",
               "guard": "SetInitFromPlayer"
             },
             {
@@ -41905,7 +48866,7 @@
               "gameField": "SetActionPointCount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Standard action points given to the unit before the tree runs.",
               "guard": "SetSetActionPointCount"
             },
             {
@@ -41915,7 +48876,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -41925,7 +48886,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -41935,7 +48896,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -41945,7 +48906,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -41955,7 +48916,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -41965,7 +48926,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -41975,7 +48936,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -41985,7 +48946,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -41995,7 +48956,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -42005,7 +48966,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -42015,7 +48976,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -42025,7 +48986,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -42035,7 +48996,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -42045,7 +49006,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -42055,7 +49016,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -42065,7 +49026,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -42075,7 +49036,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -42085,7 +49046,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -42095,7 +49056,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -42105,7 +49066,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -42115,7 +49076,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -42125,7 +49086,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -42135,7 +49096,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -42145,7 +49106,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -42155,7 +49116,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -42165,7 +49126,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -42175,7 +49136,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -42185,7 +49146,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -42195,7 +49156,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -42205,7 +49166,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -42215,7 +49176,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -42225,7 +49186,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -42235,7 +49196,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -42245,7 +49206,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -42255,7 +49216,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -42265,7 +49226,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -42275,7 +49236,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -42285,7 +49246,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -42295,7 +49256,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -42303,9 +49264,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_ScanningProtocol",
+          "class": "X2AbilityEffectsEditor_SmokeGrenade",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_ScanningProtocol",
+          "gameClass": "X2Effect_SmokeGrenade",
           "catchAll": false,
           "fields": [
             {
@@ -42315,7 +49276,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -42325,7 +49286,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -42335,7 +49296,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -42345,7 +49306,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -42355,7 +49316,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -42365,7 +49326,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -42375,7 +49336,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -42385,7 +49346,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -42395,7 +49356,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -42405,7 +49366,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -42415,7 +49376,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -42425,7 +49386,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -42435,7 +49396,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -42445,7 +49406,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -42455,7 +49416,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -42465,7 +49426,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -42475,7 +49436,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -42485,7 +49446,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -42495,7 +49456,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -42509,14 +49470,14 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "LookAtDuration",
-              "type": "float",
+              "config": "HitMod",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "LookAtDuration",
+              "gameField": "HitMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetLookAtDuration"
+              "description": "Hit chance modifier applied.",
+              "guard": "SetHitMod"
             },
             {
               "config": "InfiniteDuration",
@@ -42525,7 +49486,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -42535,7 +49496,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -42545,7 +49506,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -42555,7 +49516,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -42565,7 +49526,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -42575,7 +49536,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -42585,7 +49546,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -42595,7 +49556,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -42605,7 +49566,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -42615,7 +49576,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -42625,7 +49586,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -42635,7 +49596,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -42645,7 +49606,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -42655,7 +49616,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -42665,7 +49626,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -42675,7 +49636,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -42685,7 +49646,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -42695,7 +49656,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -42705,7 +49666,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -42715,7 +49676,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -42725,7 +49686,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -42735,7 +49696,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -42745,7 +49706,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -42755,7 +49716,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -42765,7 +49726,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -42775,7 +49736,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -42785,7 +49746,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -42795,7 +49756,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -42805,7 +49766,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -42815,7 +49776,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -42825,7 +49786,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -42835,7 +49796,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -42845,7 +49806,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -42855,7 +49816,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -42865,7 +49826,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -42875,7 +49836,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -42885,7 +49846,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -42895,7 +49856,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -42905,7 +49866,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -42913,9 +49874,9 @@
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_SmokeGrenade",
+          "class": "X2AbilityEffectsEditor_Solace",
           "extends": "X2AbilityEffectsEditor_Persistent",
-          "gameClass": "X2Effect_SmokeGrenade",
+          "gameClass": "X2Effect_Solace",
           "catchAll": false,
           "fields": [
             {
@@ -42925,7 +49886,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -42935,7 +49896,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -42945,7 +49906,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -42955,7 +49916,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -42965,7 +49926,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -42975,7 +49936,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -42985,7 +49946,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -42995,7 +49956,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -43005,7 +49966,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -43015,7 +49976,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -43025,7 +49986,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -43035,7 +49996,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -43045,7 +50006,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -43055,7 +50016,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -43065,7 +50026,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -43075,7 +50036,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -43085,7 +50046,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -43095,7 +50056,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -43105,7 +50066,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -43119,14 +50080,15 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "HitMod",
-              "type": "int",
-              "kind": "scalar",
-              "gameField": "HitMod",
+              "config": "DamageTypeImmunities",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypeImmunities",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetHitMod"
+              "description": "Damage types the affected unit is immune to while the effect lasts.",
+              "modeField": "DamageTypeImmunitiesMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
               "config": "InfiniteDuration",
@@ -43135,7 +50097,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -43145,7 +50107,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -43155,7 +50117,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -43165,7 +50127,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -43175,7 +50137,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -43185,7 +50147,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -43195,7 +50157,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -43205,7 +50167,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -43215,7 +50177,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -43225,7 +50187,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -43235,7 +50197,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -43245,7 +50207,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -43255,7 +50217,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -43265,7 +50227,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -43275,7 +50237,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -43285,7 +50247,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -43295,7 +50257,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -43305,7 +50267,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -43315,7 +50277,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -43325,7 +50287,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -43335,7 +50297,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -43345,7 +50307,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -43355,7 +50317,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -43365,7 +50327,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -43375,7 +50337,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -43385,7 +50347,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -43395,7 +50357,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -43405,7 +50367,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -43415,7 +50377,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -43425,7 +50387,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -43435,7 +50397,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -43445,7 +50407,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -43455,7 +50417,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -43465,7 +50427,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -43475,7 +50437,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -43485,7 +50447,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -43495,7 +50457,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -43505,7 +50467,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -43515,7 +50477,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -43535,7 +50497,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -43545,7 +50507,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -43555,7 +50517,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -43565,7 +50527,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -43575,7 +50537,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -43585,7 +50547,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -43595,7 +50557,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -43605,7 +50567,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -43615,7 +50577,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -43625,7 +50587,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -43635,7 +50597,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -43645,7 +50607,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -43655,7 +50617,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -43665,7 +50627,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -43675,7 +50637,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -43685,7 +50647,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -43695,7 +50657,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -43705,7 +50667,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -43715,7 +50677,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -43735,7 +50697,7 @@
               "gameField": "DestructibleArchetype",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Archetype path of the destructible actor spawned.",
               "guard": "SetDestructibleArchetype"
             },
             {
@@ -43745,7 +50707,7 @@
               "gameField": "bDestroyOnRemoval",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Destroy the spawned actor when the effect is removed.",
               "guard": "SetDestroyOnRemoval"
             },
             {
@@ -43755,7 +50717,7 @@
               "gameField": "bTargetableBySpawnedTeamOnly",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only the team that spawned the actor can target it.",
               "guard": "SetTargetableBySpawnedTeamOnly"
             },
             {
@@ -43765,7 +50727,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -43775,7 +50737,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -43785,7 +50747,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -43795,7 +50757,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -43805,7 +50767,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -43815,7 +50777,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -43825,7 +50787,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -43835,7 +50797,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -43845,7 +50807,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -43855,7 +50817,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -43865,7 +50827,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -43875,7 +50837,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -43885,7 +50847,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -43895,7 +50857,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -43905,7 +50867,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -43915,7 +50877,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -43925,7 +50887,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -43935,7 +50897,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -43945,7 +50907,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -43955,7 +50917,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -43965,7 +50927,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -43975,7 +50937,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -43985,7 +50947,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -43995,7 +50957,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -44005,7 +50967,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -44015,7 +50977,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -44025,7 +50987,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -44035,7 +50997,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -44045,7 +51007,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -44055,7 +51017,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -44065,7 +51027,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -44075,7 +51037,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -44085,7 +51047,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -44095,7 +51057,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -44105,7 +51067,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -44115,7 +51077,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -44125,7 +51087,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -44135,7 +51097,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -44145,7 +51107,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -44170,7 +51132,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -44180,7 +51142,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -44190,7 +51152,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -44200,7 +51162,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -44210,7 +51172,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -44220,7 +51182,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -44230,7 +51192,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -44240,7 +51202,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -44250,7 +51212,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -44260,7 +51222,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -44270,7 +51232,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -44280,7 +51242,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -44290,7 +51252,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -44300,7 +51262,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -44310,7 +51272,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -44320,7 +51282,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -44330,7 +51292,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -44340,7 +51302,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -44350,7 +51312,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -44370,7 +51332,7 @@
               "gameField": "UnitToSpawnName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Character template of the unit spawned.",
               "guard": "SetUnitToSpawnName"
             },
             {
@@ -44380,7 +51342,7 @@
               "gameField": "bClearTileBlockedByTargetUnitFlag",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Spawn on the target's own tile.",
               "guard": "SetClearTileBlockedByTargetUnitFlag"
             },
             {
@@ -44390,7 +51352,7 @@
               "gameField": "bCopyTargetAppearance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Give the spawned unit the target's appearance. Takes precedence over CopySourceAppearance.",
               "guard": "SetCopyTargetAppearance"
             },
             {
@@ -44400,7 +51362,7 @@
               "gameField": "bCopySourceAppearance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Give the spawned unit the source's appearance.",
               "guard": "SetCopySourceAppearance"
             },
             {
@@ -44410,7 +51372,7 @@
               "gameField": "bKnockbackAffectsSpawnLocation",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Spawn where the target ended up after knockback rather than where it was hit.",
               "guard": "SetKnockbackAffectsSpawnLocation"
             },
             {
@@ -44420,7 +51382,7 @@
               "gameField": "bAddToSourceGroup",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Put the spawned unit in the source's AI group.",
               "guard": "SetAddToSourceGroup"
             },
             {
@@ -44430,7 +51392,7 @@
               "gameField": "bCopyReanimatedFromUnit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Copy the reanimated unit's inventory and abilities too, not just its appearance.",
               "guard": "SetCopyReanimatedFromUnit"
             },
             {
@@ -44440,7 +51402,7 @@
               "gameField": "bCopyReanimatedStatsFromUnit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Copy the reanimated unit's stats.",
               "guard": "SetCopyReanimatedStatsFromUnit"
             },
             {
@@ -44450,7 +51412,7 @@
               "gameField": "bSetProcessedScamperAs",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Mark the spawned unit's group as having already scampered, so it does not reveal and scamper on sight.",
               "guard": "SetSetProcessedScamperAs"
             },
             {
@@ -44460,7 +51422,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -44470,7 +51432,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -44480,7 +51442,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -44490,7 +51452,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -44500,7 +51462,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -44510,7 +51472,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -44520,7 +51482,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -44530,7 +51492,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -44540,7 +51502,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -44550,7 +51512,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -44560,7 +51522,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -44570,7 +51532,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -44580,7 +51542,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -44590,7 +51552,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -44600,7 +51562,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -44610,7 +51572,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -44620,7 +51582,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -44630,7 +51592,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -44640,7 +51602,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -44650,7 +51612,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -44660,7 +51622,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -44670,7 +51632,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -44680,7 +51642,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -44690,7 +51652,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -44700,7 +51662,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -44710,7 +51672,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -44720,7 +51682,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -44730,7 +51692,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -44740,7 +51702,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -44750,7 +51712,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -44760,7 +51722,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -44770,7 +51732,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -44780,7 +51742,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -44790,7 +51752,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -44800,7 +51762,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -44810,7 +51772,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -44820,7 +51782,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -44830,7 +51792,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -44840,12 +51802,25 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "SpawnUnitTriggerName",
+              "reason": "private/protected"
+            },
+            {
+              "name": "SpawnedUnitValueName",
+              "reason": "private/protected"
+            },
+            {
+              "name": "SpawnedThisTurnUnitValueName",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_Stasis",
@@ -44860,7 +51835,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -44870,7 +51845,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -44880,7 +51855,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -44890,7 +51865,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -44900,7 +51875,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -44910,7 +51885,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -44920,7 +51895,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -44930,7 +51905,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -44940,7 +51915,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -44950,7 +51925,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -44960,7 +51935,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -44970,7 +51945,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -44980,7 +51955,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -44990,7 +51965,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -45000,7 +51975,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -45010,7 +51985,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -45020,7 +51995,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -45030,7 +52005,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -45040,7 +52015,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -45060,7 +52035,7 @@
               "gameField": "StunStartAnim",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Animation played when stasis starts.",
               "guard": "SetStunStartAnim"
             },
             {
@@ -45070,7 +52045,7 @@
               "gameField": "StunStopAnim",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Animation played when stasis ends.",
               "guard": "SetStunStopAnim"
             },
             {
@@ -45080,7 +52055,7 @@
               "gameField": "bSkipFlyover",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Skip the flyover text.",
               "guard": "SetSkipFlyover"
             },
             {
@@ -45090,7 +52065,7 @@
               "gameField": "StartAnimBlendTime",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Blend time, in seconds, into the start animation.",
               "guard": "SetStartAnimBlendTime"
             },
             {
@@ -45100,7 +52075,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -45110,7 +52085,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -45120,7 +52095,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -45130,7 +52105,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -45140,7 +52115,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -45150,7 +52125,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -45160,7 +52135,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -45170,7 +52145,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -45180,7 +52155,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -45190,7 +52165,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -45200,7 +52175,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -45210,7 +52185,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -45220,7 +52195,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -45230,7 +52205,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -45240,7 +52215,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -45250,7 +52225,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -45260,7 +52235,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -45270,7 +52245,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -45280,7 +52255,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -45290,7 +52265,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -45300,7 +52275,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -45310,7 +52285,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -45320,7 +52295,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -45330,7 +52305,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -45340,7 +52315,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -45350,7 +52325,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -45360,7 +52335,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -45370,7 +52345,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -45380,7 +52355,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -45390,7 +52365,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -45400,7 +52375,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -45410,7 +52385,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -45420,7 +52395,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -45430,7 +52405,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -45440,7 +52415,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -45450,7 +52425,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -45460,7 +52435,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -45470,7 +52445,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -45480,12 +52455,33 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "StasisFlyover",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "StasisRemoved",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "StasisRemovedText",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "STASIS_REMOVE_EFFECTS_SOURCE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "STASIS_REMOVE_EFFECTS_TARGET",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_Stunned",
@@ -45500,7 +52496,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -45510,7 +52506,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -45520,7 +52516,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -45530,7 +52526,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -45540,7 +52536,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -45550,7 +52546,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -45560,7 +52556,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -45570,7 +52566,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -45580,7 +52576,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -45590,7 +52586,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -45600,7 +52596,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -45610,7 +52606,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -45620,7 +52616,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -45630,7 +52626,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -45640,7 +52636,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -45650,7 +52646,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -45660,7 +52656,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -45670,7 +52666,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -45680,7 +52676,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -45700,7 +52696,7 @@
               "gameField": "StunLevel",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action points the stun takes away.",
               "guard": "SetStunLevel"
             },
             {
@@ -45710,7 +52706,7 @@
               "gameField": "bSkipAnimation",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Skip the stun animations.",
               "guard": "SetSkipAnimation"
             },
             {
@@ -45720,7 +52716,7 @@
               "gameField": "StunStartAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Animation played when the stun starts, if the unit can play it.",
               "guard": "SetStunStartAnimName"
             },
             {
@@ -45730,7 +52726,7 @@
               "gameField": "StunStopAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Animation played when the stun ends.",
               "guard": "SetStunStopAnimName"
             },
             {
@@ -45740,7 +52736,7 @@
               "gameField": "StunnedTriggerName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Event fired when the unit is stunned.",
               "guard": "SetStunnedTriggerName"
             },
             {
@@ -45750,7 +52746,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -45760,7 +52756,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -45770,7 +52766,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -45780,7 +52776,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -45790,7 +52786,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -45800,7 +52796,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -45810,7 +52806,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -45820,7 +52816,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -45830,7 +52826,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -45840,7 +52836,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -45850,7 +52846,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -45860,7 +52856,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -45870,7 +52866,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -45880,7 +52876,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -45890,7 +52886,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -45900,7 +52896,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -45910,7 +52906,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -45920,7 +52916,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -45930,7 +52926,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -45940,7 +52936,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -45950,7 +52946,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -45960,7 +52956,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -45970,7 +52966,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -45980,7 +52976,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -45990,7 +52986,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -46000,7 +52996,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -46010,7 +53006,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -46020,7 +53016,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -46030,7 +53026,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -46040,7 +53036,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -46050,7 +53046,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -46060,7 +53056,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -46070,7 +53066,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -46080,7 +53076,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -46090,7 +53086,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -46100,7 +53096,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -46110,7 +53106,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -46120,7 +53116,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -46130,12 +53126,21 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "StunnedText",
+              "reason": "localized &mdash; use .int localization files"
+            },
+            {
+              "name": "RoboticStunnedText",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_SuperConcealModifier",
@@ -46150,7 +53155,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -46160,7 +53165,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -46170,7 +53175,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -46180,7 +53185,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -46190,7 +53195,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -46200,7 +53205,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -46210,7 +53215,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -46220,7 +53225,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -46230,7 +53235,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -46240,7 +53245,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -46250,7 +53255,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -46260,7 +53265,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -46270,7 +53275,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -46280,7 +53285,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -46290,7 +53295,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -46300,7 +53305,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -46310,7 +53315,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -46320,7 +53325,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -46330,7 +53335,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -46350,7 +53355,7 @@
               "gameField": "ConcealAmountScalar",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier on the base chance of losing super concealment, added to the modifier.",
               "guard": "SetConcealAmountScalar"
             },
             {
@@ -46360,7 +53365,7 @@
               "gameField": "AbilitiesAffectedFilter",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Abilities the modifier applies to. Empty means every ability.",
               "modeField": "AbilitiesAffectedFilterMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -46371,7 +53376,7 @@
               "gameField": "RemoveOnAbilityActivation",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Abilities whose activation removes the effect.",
               "modeField": "RemoveOnAbilityActivationMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -46382,7 +53387,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -46392,7 +53397,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -46402,7 +53407,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -46412,7 +53417,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -46422,7 +53427,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -46432,7 +53437,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -46442,7 +53447,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -46452,7 +53457,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -46462,7 +53467,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -46472,7 +53477,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -46482,7 +53487,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -46492,7 +53497,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -46502,7 +53507,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -46512,7 +53517,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -46522,7 +53527,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -46532,7 +53537,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -46542,7 +53547,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -46552,7 +53557,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -46562,7 +53567,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -46572,7 +53577,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -46582,7 +53587,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -46592,7 +53597,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -46602,7 +53607,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -46612,7 +53617,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -46622,7 +53627,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -46632,7 +53637,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -46642,7 +53647,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -46652,7 +53657,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -46662,7 +53667,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -46672,7 +53677,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -46682,7 +53687,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -46692,7 +53697,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -46702,7 +53707,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -46712,7 +53717,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -46722,7 +53727,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -46732,7 +53737,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -46742,7 +53747,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -46752,7 +53757,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -46762,7 +53767,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -46782,7 +53787,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -46792,7 +53797,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -46802,7 +53807,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -46812,7 +53817,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -46822,7 +53827,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -46832,7 +53837,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -46842,7 +53847,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -46852,7 +53857,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -46862,7 +53867,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -46872,7 +53877,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -46882,7 +53887,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -46892,7 +53897,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -46902,7 +53907,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -46912,7 +53917,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -46922,7 +53927,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -46932,7 +53937,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -46942,7 +53947,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -46952,7 +53957,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -46962,7 +53967,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -46982,7 +53987,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -46992,7 +53997,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -47002,7 +54007,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -47012,7 +54017,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -47022,7 +54027,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -47032,7 +54037,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -47042,7 +54047,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -47052,7 +54057,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -47062,7 +54067,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -47072,7 +54077,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -47082,7 +54087,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -47092,7 +54097,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -47102,7 +54107,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -47112,7 +54117,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -47122,7 +54127,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -47132,7 +54137,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -47142,7 +54147,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -47152,7 +54157,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -47162,7 +54167,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -47172,7 +54177,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -47182,7 +54187,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -47192,7 +54197,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -47202,7 +54207,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -47212,7 +54217,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -47222,7 +54227,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -47232,7 +54237,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -47242,7 +54247,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -47252,7 +54257,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -47262,7 +54267,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -47272,7 +54277,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -47282,7 +54287,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -47292,7 +54297,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -47302,7 +54307,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -47312,7 +54317,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -47322,7 +54327,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -47332,7 +54337,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -47342,7 +54347,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -47352,7 +54357,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -47362,12 +54367,29 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "SUSTAINTRIGGERUNITCHECK_ARRAY",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "SustainUsed",
+              "reason": "private/protected"
+            },
+            {
+              "name": "SustainEvent",
+              "reason": "private/protected"
+            },
+            {
+              "name": "SustainTriggeredEvent",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_Sustained",
@@ -47382,7 +54404,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -47392,7 +54414,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -47402,7 +54424,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -47412,7 +54434,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -47422,7 +54444,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -47432,7 +54454,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -47442,7 +54464,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -47452,7 +54474,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -47462,7 +54484,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -47472,7 +54494,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -47482,7 +54504,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -47492,7 +54514,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -47502,7 +54524,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -47512,7 +54534,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -47522,7 +54544,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -47532,7 +54554,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -47542,7 +54564,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -47552,7 +54574,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -47562,7 +54584,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -47582,7 +54604,7 @@
               "gameField": "SustainedAbilityName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ability on the source that is fired again once a full turn completes, to keep the effect going.",
               "guard": "SetSustainedAbilityName"
             },
             {
@@ -47592,7 +54614,7 @@
               "gameField": "FragileAmount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Damage the source may take in a full turn before the effect breaks. 0 never breaks it.",
               "guard": "SetFragileAmount"
             },
             {
@@ -47602,7 +54624,7 @@
               "gameField": "EffectsToRemoveFromSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effects removed from the source when this effect ends.",
               "modeField": "EffectsToRemoveFromSourceMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -47613,7 +54635,7 @@
               "gameField": "EffectsToRemoveFromTarget",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effects removed from the target when this effect ends.",
               "modeField": "EffectsToRemoveFromTargetMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -47624,7 +54646,7 @@
               "gameField": "RegisterAdditionalEventsLikeImpair",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra events on the source that end the effect as if the source had become impaired.",
               "modeField": "RegisterAdditionalEventsLikeImpairMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -47635,7 +54657,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -47645,7 +54667,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -47655,7 +54677,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -47665,7 +54687,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -47675,7 +54697,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -47685,7 +54707,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -47695,7 +54717,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -47705,7 +54727,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -47715,7 +54737,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -47725,7 +54747,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -47735,7 +54757,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -47745,7 +54767,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -47755,7 +54777,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -47765,7 +54787,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -47775,7 +54797,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -47785,7 +54807,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -47795,7 +54817,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -47805,7 +54827,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -47815,7 +54837,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -47825,7 +54847,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -47835,7 +54857,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -47845,7 +54867,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -47855,7 +54877,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -47865,7 +54887,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -47875,7 +54897,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -47885,7 +54907,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -47895,7 +54917,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -47905,7 +54927,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -47915,7 +54937,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -47925,7 +54947,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -47935,7 +54957,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -47945,7 +54967,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -47955,7 +54977,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -47965,7 +54987,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -47975,7 +54997,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -47985,7 +55007,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -47995,7 +55017,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -48005,7 +55027,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -48015,7 +55037,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -48035,7 +55057,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -48045,7 +55067,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -48055,7 +55077,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -48065,7 +55087,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -48075,7 +55097,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -48085,7 +55107,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -48095,7 +55117,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -48105,7 +55127,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -48115,7 +55137,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -48125,7 +55147,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -48135,7 +55157,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -48145,7 +55167,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -48155,7 +55177,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -48165,7 +55187,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -48175,7 +55197,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -48185,7 +55207,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -48195,7 +55217,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -48205,7 +55227,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -48215,7 +55237,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -48235,7 +55257,7 @@
               "gameField": "AimMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Aim added.",
               "guard": "SetAimMod"
             },
             {
@@ -48245,7 +55267,7 @@
               "gameField": "CritChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Crit chance added.",
               "guard": "SetCritChance"
             },
             {
@@ -48255,7 +55277,7 @@
               "gameField": "CritDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Crit damage added.",
               "guard": "SetCritDamage"
             },
             {
@@ -48265,7 +55287,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -48275,7 +55297,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -48285,7 +55307,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -48295,7 +55317,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -48305,7 +55327,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -48315,7 +55337,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -48325,7 +55347,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -48335,7 +55357,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -48345,7 +55367,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -48355,7 +55377,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -48365,7 +55387,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -48375,7 +55397,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -48385,7 +55407,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -48395,7 +55417,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -48405,7 +55427,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -48415,7 +55437,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -48425,7 +55447,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -48435,7 +55457,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -48445,7 +55467,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -48455,7 +55477,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -48465,7 +55487,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -48475,7 +55497,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -48485,7 +55507,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -48495,7 +55517,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -48505,7 +55527,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -48515,7 +55537,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -48525,7 +55547,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -48535,7 +55557,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -48545,7 +55567,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -48555,7 +55577,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -48565,7 +55587,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -48575,7 +55597,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -48585,7 +55607,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -48595,7 +55617,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -48605,7 +55627,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -48615,7 +55637,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -48625,7 +55647,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -48635,7 +55657,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -48645,7 +55667,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -48665,7 +55687,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -48675,7 +55697,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -48685,7 +55707,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -48695,7 +55717,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -48705,7 +55727,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -48715,7 +55737,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -48725,7 +55747,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -48735,7 +55757,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -48745,7 +55767,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -48755,7 +55777,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -48765,7 +55787,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -48775,7 +55797,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -48785,7 +55807,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -48795,7 +55817,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -48805,7 +55827,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -48815,7 +55837,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -48825,7 +55847,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -48835,7 +55857,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -48845,7 +55867,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -48865,7 +55887,7 @@
               "gameField": "BonusDmg",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Bonus damage: a flat amount with MODOP_Addition, or a multiplier on the damage with MODOP_Multiplication.",
               "guard": "SetBonusDmgFloat"
             },
             {
@@ -48875,7 +55897,7 @@
               "gameField": "BonusModType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "How BonusDmgFloat is applied: MODOP_Addition or MODOP_Multiplication.",
               "guard": "SetBonusModType"
             },
             {
@@ -48885,7 +55907,7 @@
               "gameField": "WithinTileDistance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Farthest distance to the target, in tiles, at which the bonus applies.",
               "guard": "SetWithinTileDistance"
             },
             {
@@ -48895,7 +55917,7 @@
               "gameField": "bPrimaryTargetOnly",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only apply to the attack's primary target.",
               "guard": "SetPrimaryTargetOnly"
             },
             {
@@ -48905,7 +55927,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -48915,7 +55937,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -48925,7 +55947,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -48935,7 +55957,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -48945,7 +55967,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -48955,7 +55977,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -48965,7 +55987,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -48975,7 +55997,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -48985,7 +56007,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -48995,7 +56017,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -49005,7 +56027,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -49015,7 +56037,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -49025,7 +56047,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -49035,7 +56057,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -49045,7 +56067,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -49055,7 +56077,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -49065,7 +56087,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -49075,7 +56097,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -49085,7 +56107,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -49095,7 +56117,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -49105,7 +56127,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -49115,7 +56137,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -49125,7 +56147,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -49135,7 +56157,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -49145,7 +56167,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -49155,7 +56177,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -49165,7 +56187,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -49175,7 +56197,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -49185,7 +56207,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -49195,7 +56217,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -49205,7 +56227,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -49215,7 +56237,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -49225,7 +56247,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -49235,7 +56257,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -49245,7 +56267,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -49255,7 +56277,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -49265,7 +56287,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -49275,7 +56297,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -49285,7 +56307,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -49305,7 +56327,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -49315,7 +56337,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -49325,7 +56347,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -49335,7 +56357,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -49345,7 +56367,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -49355,7 +56377,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -49365,7 +56387,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -49375,7 +56397,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -49385,7 +56407,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -49395,7 +56417,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -49405,7 +56427,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -49415,7 +56437,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -49425,7 +56447,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -49435,7 +56457,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -49445,7 +56467,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -49455,7 +56477,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -49465,7 +56487,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -49475,7 +56497,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -49485,7 +56507,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -49505,7 +56527,7 @@
               "gameField": "BonusDmg",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Bonus damage: a flat amount with MODOP_Addition, or a multiplier on the damage with MODOP_Multiplication.",
               "guard": "SetBonusDmgFloat"
             },
             {
@@ -49515,7 +56537,7 @@
               "gameField": "BonusModType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "How BonusDmgFloat is applied: MODOP_Addition or MODOP_Multiplication.",
               "guard": "SetBonusModType"
             },
             {
@@ -49525,7 +56547,7 @@
               "gameField": "BonusDamageTypes",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Damage types the bonus applies to.",
               "modeField": "BonusDamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -49536,7 +56558,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -49546,7 +56568,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -49556,7 +56578,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -49566,7 +56588,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -49576,7 +56598,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -49586,7 +56608,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -49596,7 +56618,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -49606,7 +56628,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -49616,7 +56638,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -49626,7 +56648,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -49636,7 +56658,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -49646,7 +56668,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -49656,7 +56678,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -49666,7 +56688,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -49676,7 +56698,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -49686,7 +56708,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -49696,7 +56718,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -49706,7 +56728,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -49716,7 +56738,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -49726,7 +56748,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -49736,7 +56758,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -49746,7 +56768,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -49756,7 +56778,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -49766,7 +56788,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -49776,7 +56798,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -49786,7 +56808,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -49796,7 +56818,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -49806,7 +56828,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -49816,7 +56838,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -49826,7 +56848,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -49836,7 +56858,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -49846,7 +56868,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -49856,7 +56878,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -49866,7 +56888,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -49876,7 +56898,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -49886,7 +56908,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -49896,7 +56918,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -49906,7 +56928,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -49916,7 +56938,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -49936,7 +56958,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -49946,7 +56968,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -49956,7 +56978,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -49966,7 +56988,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -49976,7 +56998,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -49986,7 +57008,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -49996,7 +57018,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -50006,7 +57028,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -50016,7 +57038,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -50026,7 +57048,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -50036,7 +57058,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -50046,7 +57068,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -50056,7 +57078,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -50066,7 +57088,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -50076,7 +57098,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -50086,7 +57108,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -50096,7 +57118,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -50106,7 +57128,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -50116,7 +57138,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -50136,7 +57158,7 @@
               "gameField": "bApplyAsTarget",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Apply the modifiers to attacks against the unit rather than attacks it makes.",
               "guard": "SetApplyAsTarget"
             },
             {
@@ -50165,7 +57187,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -50175,7 +57197,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -50185,7 +57207,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -50195,7 +57217,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -50205,7 +57227,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -50215,7 +57237,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -50225,7 +57247,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -50235,7 +57257,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -50245,7 +57267,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -50255,7 +57277,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -50265,7 +57287,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -50275,7 +57297,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -50285,7 +57307,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -50295,7 +57317,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -50305,7 +57327,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -50315,7 +57337,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -50325,7 +57347,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -50335,7 +57357,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -50345,7 +57367,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -50355,7 +57377,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -50365,7 +57387,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -50375,7 +57397,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -50385,7 +57407,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -50395,7 +57417,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -50405,7 +57427,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -50415,7 +57437,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -50425,7 +57447,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -50435,7 +57457,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -50445,7 +57467,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -50455,7 +57477,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -50465,7 +57487,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -50475,7 +57497,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -50485,7 +57507,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -50495,7 +57517,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -50505,7 +57527,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -50515,7 +57537,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -50525,7 +57547,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -50535,7 +57557,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -50545,7 +57567,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -50570,7 +57592,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -50580,7 +57602,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -50590,7 +57612,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -50600,7 +57622,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -50610,7 +57632,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -50620,7 +57642,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -50630,7 +57652,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -50640,7 +57662,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -50650,7 +57672,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -50660,7 +57682,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -50670,7 +57692,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -50680,7 +57702,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -50690,7 +57712,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -50700,7 +57722,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -50710,7 +57732,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -50720,7 +57742,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -50730,7 +57752,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -50740,7 +57762,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -50750,7 +57772,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -50770,7 +57792,7 @@
               "gameField": "ConeLength",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Length of the marked cone from the source to the target.",
               "guard": "SetConeLength"
             },
             {
@@ -50780,7 +57802,7 @@
               "gameField": "ConeEndDiameter",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Diameter of the marked cone at its far end.",
               "guard": "SetConeEndDiameter"
             },
             {
@@ -50790,7 +57812,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -50800,7 +57822,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -50810,7 +57832,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -50820,7 +57842,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -50830,7 +57852,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -50840,7 +57862,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -50850,7 +57872,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -50860,7 +57882,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -50870,7 +57892,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -50880,7 +57902,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -50890,7 +57912,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -50900,7 +57922,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -50910,7 +57932,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -50920,7 +57942,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -50930,7 +57952,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -50940,7 +57962,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -50950,7 +57972,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -50960,7 +57982,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -50970,7 +57992,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -50980,7 +58002,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -50990,7 +58012,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -51000,7 +58022,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -51010,7 +58032,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -51020,7 +58042,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -51030,7 +58052,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -51040,7 +58062,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -51050,7 +58072,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -51060,7 +58082,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -51070,7 +58092,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -51080,7 +58102,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -51090,7 +58112,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -51100,7 +58122,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -51110,7 +58132,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -51120,7 +58142,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -51130,7 +58152,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -51140,7 +58162,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -51150,7 +58172,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -51160,7 +58182,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -51170,7 +58192,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -51190,7 +58212,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -51200,7 +58222,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -51210,7 +58232,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -51220,7 +58242,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -51230,7 +58252,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -51240,7 +58262,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -51250,7 +58272,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -51260,7 +58282,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -51270,7 +58292,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -51280,7 +58302,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -51290,7 +58312,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -51300,7 +58322,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -51310,7 +58332,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -51320,7 +58342,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -51330,7 +58352,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -51340,7 +58362,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -51350,7 +58372,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -51360,7 +58382,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -51370,7 +58392,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -51390,7 +58412,7 @@
               "gameField": "ActionPointType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Type of action point added, or removed, at the start of the turn.",
               "guard": "SetActionPointType"
             },
             {
@@ -51400,7 +58422,7 @@
               "gameField": "NumActionPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action points granted.",
               "guard": "SetNumActionPoints"
             },
             {
@@ -51410,7 +58432,7 @@
               "gameField": "bActionPointsRemoved",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Remove the action points instead of adding them.",
               "guard": "SetActionPointsRemoved"
             },
             {
@@ -51420,7 +58442,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -51430,7 +58452,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -51440,7 +58462,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -51450,7 +58472,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -51460,7 +58482,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -51470,7 +58492,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -51480,7 +58502,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -51490,7 +58512,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -51500,7 +58522,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -51510,7 +58532,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -51520,7 +58542,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -51530,7 +58552,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -51540,7 +58562,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -51550,7 +58572,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -51560,7 +58582,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -51570,7 +58592,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -51580,7 +58602,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -51590,7 +58612,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -51600,7 +58622,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -51610,7 +58632,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -51620,7 +58642,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -51630,7 +58652,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -51640,7 +58662,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -51650,7 +58672,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -51660,7 +58682,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -51670,7 +58692,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -51680,7 +58702,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -51690,7 +58712,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -51700,7 +58722,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -51710,7 +58732,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -51720,7 +58742,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -51730,7 +58752,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -51740,7 +58762,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -51750,7 +58772,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -51760,7 +58782,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -51770,7 +58792,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -51780,7 +58802,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -51790,7 +58812,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -51800,7 +58822,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -51820,7 +58842,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -51830,7 +58852,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -51840,7 +58862,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -51850,7 +58872,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -51860,7 +58882,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -51870,7 +58892,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -51880,7 +58902,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -51890,7 +58912,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -51900,7 +58922,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -51910,7 +58932,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -51920,7 +58942,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -51930,7 +58952,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -51940,7 +58962,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -51950,7 +58972,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -51960,7 +58982,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -51970,7 +58992,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -51980,7 +59002,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -51990,7 +59012,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -52000,7 +59022,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -52020,7 +59042,7 @@
               "gameField": "BonusDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Bonus damage added when the effect's condition is met.",
               "guard": "SetBonusDamage"
             },
             {
@@ -52030,7 +59052,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -52040,7 +59062,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -52050,7 +59072,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -52060,7 +59082,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -52070,7 +59092,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -52080,7 +59102,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -52090,7 +59112,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -52100,7 +59122,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -52110,7 +59132,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -52120,7 +59142,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -52130,7 +59152,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -52140,7 +59162,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -52150,7 +59172,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -52160,7 +59182,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -52170,7 +59192,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -52180,7 +59202,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -52190,7 +59212,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -52200,7 +59222,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -52210,7 +59232,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -52220,7 +59242,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -52230,7 +59252,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -52240,7 +59262,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -52250,168 +59272,388 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
-              "config": "CustomIdleOverrideAnim",
-              "type": "name",
+              "config": "CustomIdleOverrideAnim",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "CustomIdleOverrideAnim",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
+              "guard": "SetCustomIdleOverrideAnim"
+            },
+            {
+              "config": "EffectName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
+              "guard": "SetEffectName"
+            },
+            {
+              "config": "AbilitySourceName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "AbilitySourceName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
+              "guard": "SetAbilitySourceName"
+            },
+            {
+              "config": "EffectAppliedEventName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "EffectAppliedEventName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
+              "guard": "SetEffectAppliedEventName"
+            },
+            {
+              "config": "ChanceEventTriggerName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "ChanceEventTriggerName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
+              "guard": "SetChanceEventTriggerName"
+            },
+            {
+              "config": "VFXSocket",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocket",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
+              "guard": "SetVFXSocket"
+            },
+            {
+              "config": "VFXSocketsArrayName",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "VFXSocketsArrayName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
+              "guard": "SetVFXSocketsArrayName"
+            },
+            {
+              "config": "FriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown in the unit’s status UI.",
+              "guard": "SetFriendlyName"
+            },
+            {
+              "config": "FriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "FriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown beneath FriendlyName in the status UI.",
+              "guard": "SetFriendlyDescription"
+            },
+            {
+              "config": "IconImage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "IconImage",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the status icon shown in the UI.",
+              "guard": "SetIconImage"
+            },
+            {
+              "config": "SourceFriendlyName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
+              "guard": "SetSourceFriendlyName"
+            },
+            {
+              "config": "SourceFriendlyDescription",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceFriendlyDescription",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Description shown on the applying unit.",
+              "guard": "SetSourceFriendlyDescription"
+            },
+            {
+              "config": "SourceIconLabel",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "SourceIconLabel",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Short label drawn on the applying unit’s icon.",
+              "guard": "SetSourceIconLabel"
+            },
+            {
+              "config": "StatusIcon",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "StatusIcon",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
+              "guard": "SetStatusIcon"
+            },
+            {
+              "config": "VFXTemplateName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "VFXTemplateName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
+              "guard": "SetVFXTemplateName"
+            },
+            {
+              "config": "PersistentPerkName",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "PersistentPerkName",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
+              "description": "Perk effect played on the unit while this effect is active.",
+              "guard": "SetPersistentPerkName"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
+        {
+          "class": "X2AbilityEffectsEditor_AlertTheLost",
+          "extends": "X2AbilityEffectsEditor_Base",
+          "gameClass": "X2Effect_AlertTheLost",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "CustomIdleOverrideAnim",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetCustomIdleOverrideAnim"
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
             },
             {
-              "config": "EffectName",
-              "type": "name",
+              "config": "IsImpairing",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "EffectName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetEffectName"
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
             },
             {
-              "config": "AbilitySourceName",
-              "type": "name",
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "AbilitySourceName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetAbilitySourceName"
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
             },
             {
-              "config": "EffectAppliedEventName",
-              "type": "name",
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "EffectAppliedEventName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetEffectAppliedEventName"
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
             },
             {
-              "config": "ChanceEventTriggerName",
-              "type": "name",
+              "config": "ShowImmunity",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "ChanceEventTriggerName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetChanceEventTriggerName"
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
             },
             {
-              "config": "VFXSocket",
-              "type": "name",
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "VFXSocket",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetVFXSocket"
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
             },
             {
-              "config": "VFXSocketsArrayName",
-              "type": "name",
+              "config": "AppliesDamage",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "VFXSocketsArrayName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetVFXSocketsArrayName"
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
             },
             {
-              "config": "FriendlyName",
-              "type": "string",
+              "config": "CanBeRedirected",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "FriendlyName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetFriendlyName"
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
             },
             {
-              "config": "FriendlyDescription",
-              "type": "string",
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
               "kind": "scalar",
-              "gameField": "FriendlyDescription",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetFriendlyDescription"
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
             },
             {
-              "config": "IconImage",
-              "type": "string",
+              "config": "MinStatContestResult",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "IconImage",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetIconImage"
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
             },
             {
-              "config": "SourceFriendlyName",
-              "type": "string",
+              "config": "MaxStatContestResult",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "SourceFriendlyName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetSourceFriendlyName"
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
             },
             {
-              "config": "SourceFriendlyDescription",
-              "type": "string",
+              "config": "DelayVisualizationSec",
+              "type": "float",
               "kind": "scalar",
-              "gameField": "SourceFriendlyDescription",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetSourceFriendlyDescription"
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
             },
             {
-              "config": "SourceIconLabel",
+              "config": "OverrideMissMessage",
               "type": "string",
               "kind": "scalar",
-              "gameField": "SourceIconLabel",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetSourceIconLabel"
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
             },
             {
-              "config": "StatusIcon",
-              "type": "string",
-              "kind": "scalar",
-              "gameField": "StatusIcon",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetStatusIcon"
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
-              "config": "VFXTemplateName",
-              "type": "string",
-              "kind": "scalar",
-              "gameField": "VFXTemplateName",
-              "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetVFXTemplateName"
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "PersistentPerkName",
-              "type": "string",
+              "config": "AlertRangeMeters",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "PersistentPerkName",
+              "gameField": "AlertRangeMeters",
               "origin": "derived",
-              "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
-              "guard": "SetPersistentPerkName"
+              "inheritedFrom": null,
+              "description": "Radius in meters within which Lost are alerted.",
+              "guard": "SetAlertRangeMeters"
             }
           ],
           "abstract": false,
@@ -52430,7 +59672,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -52440,7 +59682,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -52450,7 +59692,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -52460,7 +59702,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -52470,7 +59712,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -52480,7 +59722,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -52490,7 +59732,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -52500,7 +59742,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -52510,7 +59752,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -52520,7 +59762,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -52530,7 +59772,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -52540,7 +59782,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -52550,7 +59792,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -52560,7 +59802,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -52570,7 +59812,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -52580,7 +59822,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -52590,7 +59832,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -52600,7 +59842,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -52610,7 +59852,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -52630,7 +59872,7 @@
               "gameField": "EnvironmentalDamageAmount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Environmental damage dealt to terrain and cover.",
               "guard": "SetEnvironmentalDamageAmount"
             },
             {
@@ -52640,7 +59882,7 @@
               "gameField": "DamageTypeTemplateName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Damage type of the environmental damage.",
               "guard": "SetDamageTypeTemplateName"
             },
             {
@@ -52650,7 +59892,7 @@
               "gameField": "PlusNumZTiles",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra tiles of height hit above the affected tile.",
               "guard": "SetPlusNumZTiles"
             },
             {
@@ -52660,7 +59902,7 @@
               "gameField": "bUseWeaponEnvironmentalDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Use the source weapon's environmental damage instead of EnvironmentalDamageAmount.",
               "guard": "SetUseWeaponEnvironmentalDamage"
             },
             {
@@ -52670,7 +59912,7 @@
               "gameField": "bUseWeaponDamageType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Use the source weapon's damage type instead of DamageTypeTemplateName.",
               "guard": "SetUseWeaponDamageType"
             },
             {
@@ -52680,7 +59922,7 @@
               "gameField": "bHitSourceTile",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Apply the damage at the source's tile.",
               "guard": "SetHitSourceTile"
             },
             {
@@ -52690,7 +59932,7 @@
               "gameField": "bHitTargetTile",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Apply the damage at the target's tile.",
               "guard": "SetHitTargetTile"
             },
             {
@@ -52700,7 +59942,7 @@
               "gameField": "bHitAdjacentDestructibles",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Also damage destructibles adjacent to the hit tile along the damage direction.",
               "guard": "SetHitAdjacentDestructibles"
             },
             {
@@ -52710,7 +59952,7 @@
               "gameField": "bAllowDestructionOfDamageCauseCover",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "When a unit caused the damage, allow it to destroy that unit's own cover, which is normally protected.",
               "guard": "SetAllowDestructionOfDamageCauseCover"
             }
           ],
@@ -52730,7 +59972,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -52740,7 +59982,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -52750,7 +59992,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -52760,7 +60002,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -52770,7 +60012,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -52780,7 +60022,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -52790,7 +60032,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -52800,7 +60042,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -52810,7 +60052,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -52820,7 +60062,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -52830,7 +60072,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -52840,7 +60082,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -52850,7 +60092,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -52860,7 +60102,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -52870,7 +60112,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -52880,7 +60122,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -52890,7 +60132,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -52900,7 +60142,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -52910,7 +60152,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -52930,7 +60172,7 @@
               "gameField": "PerUseHP",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "HP healed per application.",
               "guard": "SetPerUseHP"
             },
             {
@@ -52940,7 +60182,7 @@
               "gameField": "IncreasedHealProject",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Research that, once completed, switches the heal to IncreasedPerUseHP.",
               "guard": "SetIncreasedHealProject"
             },
             {
@@ -52950,12 +60192,17 @@
               "gameField": "IncreasedPerUseHP",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "HP healed per application once IncreasedHealProject is researched.",
               "guard": "SetIncreasedPerUseHP"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "HealedMessage",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_ApplyWeaponDamage",
@@ -52970,7 +60217,361 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
+              "guard": "SetApplyOnHit"
+            },
+            {
+              "config": "ApplyOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied even when the ability misses.",
+              "guard": "SetApplyOnMiss"
+            },
+            {
+              "config": "ApplyChance",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "ApplyChance",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
+              "guard": "SetApplyChance"
+            },
+            {
+              "config": "ApplyToWorldOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
+              "guard": "SetApplyToWorldOnHit"
+            },
+            {
+              "config": "ApplyToWorldOnMiss",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyToWorldOnMiss",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
+              "guard": "SetApplyToWorldOnMiss"
+            },
+            {
+              "config": "UseSourcePlayerState",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bUseSourcePlayerState",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
+              "guard": "SetUseSourcePlayerState"
+            },
+            {
+              "config": "IsImpairing",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairing",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
+              "guard": "SetIsImpairing"
+            },
+            {
+              "config": "IsImpairingMomentarily",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIsImpairingMomentarily",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
+              "guard": "SetIsImpairingMomentarily"
+            },
+            {
+              "config": "BringRemoveVisualizationForward",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBringRemoveVisualizationForward",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
+              "guard": "SetBringRemoveVisualizationForward"
+            },
+            {
+              "config": "ShowImmunity",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunity",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
+              "guard": "SetShowImmunity"
+            },
+            {
+              "config": "ShowImmunityAnyFailure",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bShowImmunityAnyFailure",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
+              "guard": "SetShowImmunityAnyFailure"
+            },
+            {
+              "config": "AppliesDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAppliesDamage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
+              "guard": "SetAppliesDamage"
+            },
+            {
+              "config": "CanBeRedirected",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bCanBeRedirected",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
+              "guard": "SetCanBeRedirected"
+            },
+            {
+              "config": "HideDeathWorldMessage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bHideDeathWorldMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
+              "guard": "SetHideDeathWorldMessage"
+            },
+            {
+              "config": "MinStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MinStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
+              "guard": "SetMinStatContestResult"
+            },
+            {
+              "config": "MaxStatContestResult",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "MaxStatContestResult",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
+              "guard": "SetMaxStatContestResult"
+            },
+            {
+              "config": "DelayVisualizationSec",
+              "type": "float",
+              "kind": "scalar",
+              "gameField": "DelayVisualizationSec",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
+              "guard": "SetDelayVisualizationSec"
+            },
+            {
+              "config": "OverrideMissMessage",
+              "type": "string",
+              "kind": "scalar",
+              "gameField": "OverrideMissMessage",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
+              "guard": "SetOverrideMissMessage"
+            },
+            {
+              "config": "DamageTypes",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "DamageTypes",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
+              "modeField": "DamageTypesMode",
+              "modeEnum": "ENameArrayEditMode"
+            },
+            {
+              "config": "TargetConditions",
+              "type": "array<ConditionEdit>",
+              "kind": "nested",
+              "gameField": "TargetConditions",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
+            },
+            {
+              "config": "ExplosiveDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bExplosiveDamage",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Counts the damage as explosive, so explosive-specific rules such as Blast Padding apply.",
+              "guard": "SetExplosiveDamage"
+            },
+            {
+              "config": "IgnoreBaseDamage",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnoreBaseDamage",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Leave out the weapon's base damage; only the effect's own damage and tagged extra damage apply.",
+              "guard": "SetIgnoreBaseDamage"
+            },
+            {
+              "config": "DamageTag",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "DamageTag",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Tag selecting one of the weapon's ExtraDamage entries and the upgrade bonus damage with the same tag.",
+              "guard": "SetDamageTag"
+            },
+            {
+              "config": "AlwaysKillsCivilians",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAlwaysKillsCivilians",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Civilian targets die outright regardless of the damage rolled.",
+              "guard": "SetAlwaysKillsCivilians"
+            },
+            {
+              "config": "ApplyWorldEffectsForEachTargetLocation",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyWorldEffectsForEachTargetLocation",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Apply the ability's world effects at every target location instead of once.",
+              "guard": "SetApplyWorldEffectsForEachTargetLocation"
+            },
+            {
+              "config": "AllowFreeKill",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAllowFreeKill",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Let free-kill weapon upgrades, such as the Repeater, trigger on this damage.",
+              "guard": "SetAllowFreeKill"
+            },
+            {
+              "config": "AllowWeaponUpgrade",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bAllowWeaponUpgrade",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Let weapon upgrades add their bonus damage.",
+              "guard": "SetAllowWeaponUpgrade"
+            },
+            {
+              "config": "BypassShields",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBypassShields",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage ignores shield HP and goes straight to health.",
+              "guard": "SetBypassShields"
+            },
+            {
+              "config": "IgnoreArmor",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bIgnoreArmor",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage ignores armor.",
+              "guard": "SetIgnoreArmor"
+            },
+            {
+              "config": "BypassSustainEffects",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bBypassSustainEffects",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage ignores sustain effects that would otherwise keep the unit alive.",
+              "guard": "SetBypassSustainEffects"
+            },
+            {
+              "config": "EnvironmentalDamageAmount",
+              "type": "int",
+              "kind": "scalar",
+              "gameField": "EnvironmentalDamageAmount",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Environmental damage dealt to terrain and cover.",
+              "guard": "SetEnvironmentalDamageAmount"
+            },
+            {
+              "config": "WeaponDamageValue",
+              "type": "WeaponDamageValueEdit",
+              "kind": "nested",
+              "gameField": "EffectDamageValue",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Damage the effect adds on its own, on top of the weapon: Damage, Spread, Crit, Pierce, Shred, Rupture, PlusOne, DamageType and Tag."
+            }
+          ],
+          "abstract": false,
+          "notEditable": [
+            {
+              "name": "CurrentAbilityNameForImmunityCheck",
+              "reason": "private/protected"
+            },
+            {
+              "name": "HideVisualizationOfResultsAdditional",
+              "reason": "not yet supported"
+            },
+            {
+              "name": "NO_MINIMUM_DAMAGE",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "ARMOR_BEFORE_SHIELD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "GRAZE_DMG_MULT",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "HideVisualizationOfResults",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
+        },
+        {
+          "class": "X2AbilityEffectsEditor_Brutal",
+          "extends": "X2AbilityEffectsEditor_Base",
+          "gameClass": "X2Effect_Brutal",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "ApplyOnHit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bApplyOnHit",
+              "origin": "base",
+              "inheritedFrom": "X2AbilityEffectsEditor",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -52980,7 +60581,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -52990,7 +60591,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -53000,7 +60601,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -53010,7 +60611,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -53020,7 +60621,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -53030,7 +60631,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -53040,7 +60641,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -53050,7 +60651,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -53060,7 +60661,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -53070,7 +60671,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -53080,7 +60681,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -53090,7 +60691,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -53100,7 +60701,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -53110,7 +60711,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -53120,7 +60721,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -53130,7 +60731,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -53140,7 +60741,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -53150,7 +60751,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -53164,137 +60765,28 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "ExplosiveDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bExplosiveDamage",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetExplosiveDamage"
-            },
-            {
-              "config": "IgnoreBaseDamage",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bIgnoreBaseDamage",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetIgnoreBaseDamage"
-            },
-            {
-              "config": "DamageTag",
-              "type": "name",
-              "kind": "scalar",
-              "gameField": "DamageTag",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetDamageTag"
-            },
-            {
-              "config": "AlwaysKillsCivilians",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAlwaysKillsCivilians",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAlwaysKillsCivilians"
-            },
-            {
-              "config": "ApplyWorldEffectsForEachTargetLocation",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bApplyWorldEffectsForEachTargetLocation",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetApplyWorldEffectsForEachTargetLocation"
-            },
-            {
-              "config": "AllowFreeKill",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAllowFreeKill",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAllowFreeKill"
-            },
-            {
-              "config": "AllowWeaponUpgrade",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bAllowWeaponUpgrade",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetAllowWeaponUpgrade"
-            },
-            {
-              "config": "BypassShields",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bBypassShields",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBypassShields"
-            },
-            {
-              "config": "IgnoreArmor",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bIgnoreArmor",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetIgnoreArmor"
-            },
-            {
-              "config": "BypassSustainEffects",
-              "type": "bool",
-              "kind": "scalar",
-              "gameField": "bBypassSustainEffects",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetBypassSustainEffects"
-            },
-            {
-              "config": "EnvironmentalDamageAmount",
+              "config": "WillMod",
               "type": "int",
               "kind": "scalar",
-              "gameField": "EnvironmentalDamageAmount",
-              "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetEnvironmentalDamageAmount"
-            },
-            {
-              "config": "WeaponDamageValue",
-              "type": "WeaponDamageValueEdit",
-              "kind": "nested",
-              "gameField": "EffectDamageValue",
+              "gameField": "WillMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": ""
+              "description": "Change applied to the target's current Will; negative lowers it.",
+              "guard": "SetWillMod"
             }
           ],
           "abstract": false,
           "notEditable": [
             {
-              "name": "HideVisualizationOfResultsAdditional",
-              "reason": "not yet supported"
+              "name": "WillChangeMessage",
+              "reason": "localized &mdash; use .int localization files"
             }
           ]
         },
         {
-          "class": "X2AbilityEffectsEditor_Brutal",
+          "class": "X2AbilityEffectsEditor_EnableGlobalAbility",
           "extends": "X2AbilityEffectsEditor_Base",
-          "gameClass": "X2Effect_Brutal",
+          "gameClass": "X2Effect_EnableGlobalAbility",
           "catchAll": false,
           "fields": [
             {
@@ -53304,7 +60796,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -53314,7 +60806,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -53324,7 +60816,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -53334,7 +60826,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -53344,7 +60836,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -53354,7 +60846,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -53364,7 +60856,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -53374,7 +60866,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -53384,7 +60876,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -53394,7 +60886,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -53404,7 +60896,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -53414,7 +60906,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -53424,7 +60916,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -53434,7 +60926,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -53444,7 +60936,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -53454,7 +60946,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -53464,7 +60956,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -53474,7 +60966,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -53484,7 +60976,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -53498,23 +60990,23 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "WillMod",
-              "type": "int",
+              "config": "GlobalAbility",
+              "type": "name",
               "kind": "scalar",
-              "gameField": "WillMod",
+              "gameField": "GlobalAbility",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetWillMod"
+              "description": "Global ability switched on for the rest of the battle.",
+              "guard": "SetGlobalAbility"
             }
           ],
           "abstract": false,
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_EnableGlobalAbility",
+          "class": "X2AbilityEffectsEditor_GetOverHere",
           "extends": "X2AbilityEffectsEditor_Base",
-          "gameClass": "X2Effect_EnableGlobalAbility",
+          "gameClass": "X2Effect_GetOverHere",
           "catchAll": false,
           "fields": [
             {
@@ -53524,7 +61016,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -53534,7 +61026,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -53544,7 +61036,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -53554,7 +61046,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -53564,7 +61056,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -53574,7 +61066,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -53584,7 +61076,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -53594,7 +61086,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -53604,7 +61096,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -53614,7 +61106,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -53624,7 +61116,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -53634,7 +61126,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -53644,7 +61136,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -53654,7 +61146,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -53664,7 +61156,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -53674,7 +61166,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -53684,7 +61176,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -53694,7 +61186,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -53704,7 +61196,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -53718,23 +61210,43 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "GlobalAbility",
-              "type": "name",
+              "config": "OverrideStartAnimName",
+              "type": "Name",
               "kind": "scalar",
-              "gameField": "GlobalAbility",
+              "gameField": "OverrideStartAnimName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetGlobalAbility"
+              "description": "Animation played on the pulled unit at the start, when set.",
+              "guard": "SetOverrideStartAnimName"
+            },
+            {
+              "config": "OverrideStopAnimName",
+              "type": "Name",
+              "kind": "scalar",
+              "gameField": "OverrideStopAnimName",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Animation played on the pulled unit at the end, when set.",
+              "guard": "SetOverrideStopAnimName"
+            },
+            {
+              "config": "RequireVisibleTile",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "RequireVisibleTile",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Only pull to a neighbouring tile the target can be bound to; otherwise any free neighbouring tile will do.",
+              "guard": "SetRequireVisibleTile"
             }
           ],
           "abstract": false,
           "notEditable": []
         },
         {
-          "class": "X2AbilityEffectsEditor_GetOverHere",
-          "extends": "X2AbilityEffectsEditor_Base",
-          "gameClass": "X2Effect_GetOverHere",
+          "class": "X2AbilityEffectsEditor_GrantActionPointsWithRecord",
+          "extends": "X2AbilityEffectsEditor_GrantActionPoints",
+          "gameClass": "X2Effect_GrantActionPointsWithRecord",
           "catchAll": false,
           "fields": [
             {
@@ -53744,7 +61256,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -53754,7 +61266,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -53764,7 +61276,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -53774,7 +61286,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -53784,7 +61296,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -53794,7 +61306,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -53804,7 +61316,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -53814,7 +61326,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -53824,7 +61336,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -53834,7 +61346,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -53844,7 +61356,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -53854,7 +61366,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -53864,7 +61376,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -53874,7 +61386,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -53884,7 +61396,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -53894,7 +61406,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -53904,7 +61416,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -53914,7 +61426,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -53924,7 +61436,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -53938,34 +61450,66 @@
               "description": "Conditions attached to the effect (X2Effect.TargetConditions)"
             },
             {
-              "config": "OverrideStartAnimName",
-              "type": "Name",
-              "kind": "scalar",
-              "gameField": "OverrideStartAnimName",
+              "config": "RecordUnitValueWithGrant",
+              "type": "array<RecordData>",
+              "kind": "namearray",
+              "gameField": "RecordUnitValueWithGrant",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
-              "guard": "SetOverrideStartAnimName"
+              "description": "Unit values that accumulate the action points granted, each with its cleanup rule. Merge updates the entry with the same UnitValueName or adds it.",
+              "modeField": "RecordUnitValueWithGrantMode",
+              "modeEnum": "ENameArrayEditMode"
             },
             {
-              "config": "OverrideStopAnimName",
-              "type": "Name",
+              "config": "NumActionPoints",
+              "type": "int",
               "kind": "scalar",
-              "gameField": "OverrideStopAnimName",
+              "gameField": "NumActionPoints",
               "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetOverrideStopAnimName"
+              "inheritedFrom": "X2AbilityEffectsEditor_GrantActionPoints",
+              "description": "Action points granted.",
+              "guard": "SetNumActionPoints"
             },
             {
-              "config": "RequireVisibleTile",
+              "config": "PointType",
+              "type": "name",
+              "kind": "scalar",
+              "gameField": "PointType",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_GrantActionPoints",
+              "description": "Type of action point granted, e.g. standard or move.",
+              "guard": "SetPointType"
+            },
+            {
+              "config": "ApplyOnlyWhenOut",
               "type": "bool",
               "kind": "scalar",
-              "gameField": "RequireVisibleTile",
+              "gameField": "bApplyOnlyWhenOut",
               "origin": "derived",
-              "inheritedFrom": null,
-              "description": "",
-              "guard": "SetRequireVisibleTile"
+              "inheritedFrom": "X2AbilityEffectsEditor_GrantActionPoints",
+              "description": "Grant only when the unit has no standard action points left.",
+              "guard": "SetApplyOnlyWhenOut"
+            },
+            {
+              "config": "SelectUnit",
+              "type": "bool",
+              "kind": "scalar",
+              "gameField": "bSelectUnit",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_GrantActionPoints",
+              "description": "Select the unit in the tactical UI once the points are granted.",
+              "guard": "SetSelectUnit"
+            },
+            {
+              "config": "SkipWithEffect",
+              "type": "array<name>",
+              "kind": "namearray",
+              "gameField": "SkipWithEffect",
+              "origin": "derived",
+              "inheritedFrom": "X2AbilityEffectsEditor_GrantActionPoints",
+              "description": "Effects that, when present on the unit, skip the grant.",
+              "modeField": "SkipWithEffectMode",
+              "modeEnum": "ENameArrayEditMode"
             }
           ],
           "abstract": false,
@@ -53984,7 +61528,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -53994,7 +61538,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -54004,7 +61548,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -54014,7 +61558,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -54024,7 +61568,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -54034,7 +61578,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -54044,7 +61588,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -54054,7 +61598,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -54064,7 +61608,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -54074,7 +61618,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -54084,7 +61628,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -54094,7 +61638,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -54104,7 +61648,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -54114,7 +61658,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -54124,7 +61668,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -54134,7 +61678,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -54144,7 +61688,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -54154,7 +61698,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -54164,7 +61708,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -54184,7 +61728,7 @@
               "gameField": "NumActionPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action points granted.",
               "guard": "SetNumActionPoints"
             },
             {
@@ -54194,7 +61738,7 @@
               "gameField": "PointType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Type of action point granted, e.g. standard or move.",
               "guard": "SetPointType"
             },
             {
@@ -54204,7 +61748,7 @@
               "gameField": "bApplyOnlyWhenOut",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Grant only when the unit has no standard action points left.",
               "guard": "SetApplyOnlyWhenOut"
             },
             {
@@ -54214,7 +61758,7 @@
               "gameField": "bSelectUnit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Select the unit in the tactical UI once the points are granted.",
               "guard": "SetSelectUnit"
             },
             {
@@ -54224,7 +61768,7 @@
               "gameField": "SkipWithEffect",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effects that, when present on the unit, skip the grant.",
               "modeField": "SkipWithEffectMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -54245,7 +61789,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -54255,7 +61799,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -54265,7 +61809,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -54275,7 +61819,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -54285,7 +61829,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -54295,7 +61839,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -54305,7 +61849,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -54315,7 +61859,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -54325,7 +61869,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -54335,7 +61879,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -54345,7 +61889,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -54355,7 +61899,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -54365,7 +61909,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -54375,7 +61919,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -54385,7 +61929,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -54395,7 +61939,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -54405,7 +61949,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -54415,7 +61959,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -54425,7 +61969,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -54445,7 +61989,7 @@
               "gameField": "CohesionAmount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Cohesion added between the unit and its bondmate.",
               "guard": "SetCohesionAmount"
             }
           ],
@@ -54465,7 +62009,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -54475,7 +62019,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -54485,7 +62029,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -54495,7 +62039,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -54505,7 +62049,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -54515,7 +62059,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -54525,7 +62069,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -54535,7 +62079,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -54545,7 +62089,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -54555,7 +62099,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -54565,7 +62109,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -54575,7 +62119,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -54585,7 +62129,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -54595,7 +62139,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -54605,7 +62149,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -54615,7 +62159,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -54625,7 +62169,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -54635,7 +62179,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -54645,7 +62189,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -54665,7 +62209,7 @@
               "gameField": "KnockbackDistance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Distance the unit is knocked back, in meters.",
               "guard": "SetKnockbackDistance"
             },
             {
@@ -54675,7 +62219,7 @@
               "gameField": "bKnockbackDestroysNonFragile",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Let the knocked-back unit destroy non-fragile objects it hits.",
               "guard": "SetKnockbackDestroysNonFragile"
             },
             {
@@ -54685,7 +62229,7 @@
               "gameField": "OverrideRagdollFinishTimerSec",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Seconds before the ragdoll settles. Negative keeps the default.",
               "guard": "SetOverrideRagdollFinishTimerSec"
             },
             {
@@ -54695,12 +62239,29 @@
               "gameField": "OnlyOnDeath",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only knock back units the attack kills.",
               "guard": "SetOnlyOnDeath"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "IncrementalStepSize",
+              "reason": "private/protected"
+            },
+            {
+              "name": "DefaultDamage",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "DefaultRadius",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "KnockbackDistanceOverrides",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_LifeSteal",
@@ -54715,7 +62276,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -54725,7 +62286,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -54735,7 +62296,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -54745,7 +62306,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -54755,7 +62316,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -54765,7 +62326,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -54775,7 +62336,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -54785,7 +62346,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -54795,7 +62356,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -54805,7 +62366,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -54815,7 +62376,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -54825,7 +62386,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -54835,7 +62396,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -54845,7 +62406,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -54855,7 +62416,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -54865,7 +62426,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -54875,7 +62436,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -54885,7 +62446,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -54895,7 +62456,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -54915,7 +62476,7 @@
               "gameField": "LifeAmountMultiplier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier on the health stolen. 0 leaves the amount unchanged.",
               "guard": "SetLifeAmountMultiplier"
             }
           ],
@@ -54935,7 +62496,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -54945,7 +62506,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -54955,7 +62516,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -54965,7 +62526,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -54975,7 +62536,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -54985,7 +62546,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -54995,7 +62556,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -55005,7 +62566,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -55015,7 +62576,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -55025,7 +62586,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -55035,7 +62596,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -55045,7 +62606,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -55055,7 +62616,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -55065,7 +62626,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -55075,7 +62636,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -55085,7 +62646,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -55095,7 +62656,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -55105,7 +62666,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -55115,7 +62676,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -55135,7 +62696,7 @@
               "gameField": "AbilityToMark",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ability whose valid activation tiles are marked.",
               "guard": "SetAbilityToMark"
             },
             {
@@ -55145,7 +62706,7 @@
               "gameField": "OnlyUseTargetLocation",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Mark only the target location, ignoring the ability's multi-target area.",
               "guard": "SetOnlyUseTargetLocation"
             },
             {
@@ -55155,7 +62716,7 @@
               "gameField": "bVisualizeFlagsOnCursor",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Show the marked tiles on the targeting cursor.",
               "guard": "SetVisualizeFlagsOnCursor"
             }
           ],
@@ -55175,7 +62736,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -55185,7 +62746,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -55195,7 +62756,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -55205,7 +62766,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -55215,7 +62776,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -55225,7 +62786,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -55235,7 +62796,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -55245,7 +62806,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -55255,7 +62816,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -55265,7 +62826,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -55275,7 +62836,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -55285,7 +62846,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -55295,7 +62856,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -55305,7 +62866,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -55315,7 +62876,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -55325,7 +62886,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -55335,7 +62896,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -55345,7 +62906,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -55355,7 +62916,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -55375,7 +62936,7 @@
               "gameField": "bRemoveGroupFromInitiativeOrder",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Remove the unit's group from the initiative order.",
               "guard": "SetRemoveGroupFromInitiativeOrder"
             },
             {
@@ -55385,7 +62946,7 @@
               "gameField": "bAddGroupToInitiativeOrder",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Add the unit's group to the initiative order.",
               "guard": "SetAddGroupToInitiativeOrder"
             }
           ],
@@ -55405,7 +62966,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -55415,7 +62976,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -55425,7 +62986,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -55435,7 +62996,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -55445,7 +63006,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -55455,7 +63016,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -55465,7 +63026,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -55475,7 +63036,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -55485,7 +63046,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -55495,7 +63056,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -55505,7 +63066,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -55515,7 +63076,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -55525,7 +63086,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -55535,7 +63096,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -55545,7 +63106,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -55555,7 +63116,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -55565,7 +63126,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -55575,7 +63136,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -55585,7 +63146,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -55605,12 +63166,17 @@
               "gameField": "ModifyFocus",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Focus points added; negative removes them.",
               "guard": "SetModifyFocus"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "FlyoverText",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_LethalWeaponDamage",
@@ -55625,7 +63191,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -55635,7 +63201,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -55645,7 +63211,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -55655,7 +63221,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -55665,7 +63231,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -55675,7 +63241,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -55685,7 +63251,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -55695,7 +63261,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -55705,7 +63271,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -55715,7 +63281,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -55725,7 +63291,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -55735,7 +63301,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -55745,7 +63311,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -55755,7 +63321,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -55765,7 +63331,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -55775,7 +63341,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -55785,7 +63351,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -55795,7 +63361,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -55805,7 +63371,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -55834,7 +63400,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -55844,7 +63410,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -55854,7 +63420,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -55864,7 +63430,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -55874,7 +63440,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -55884,7 +63450,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -55894,7 +63460,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -55904,7 +63470,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -55914,7 +63480,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -55924,7 +63490,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -55934,7 +63500,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -55944,7 +63510,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -55954,7 +63520,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -55964,7 +63530,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -55974,7 +63540,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -55984,7 +63550,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -55994,7 +63560,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -56004,7 +63570,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -56014,7 +63580,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -56024,7 +63590,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -56034,7 +63600,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -56044,7 +63610,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -56054,7 +63620,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -56064,7 +63630,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -56074,7 +63640,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -56084,7 +63650,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -56094,7 +63660,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -56104,7 +63670,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -56114,7 +63680,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -56124,7 +63690,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -56134,7 +63700,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -56144,7 +63710,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -56154,7 +63720,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -56164,7 +63730,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -56174,7 +63740,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -56184,7 +63750,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -56194,7 +63760,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -56204,7 +63770,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -56214,7 +63780,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": "X2AbilityEffectsEditor_Persistent",
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -56239,7 +63805,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -56249,7 +63815,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -56259,7 +63825,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -56269,7 +63835,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -56279,7 +63845,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -56289,7 +63855,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -56299,7 +63865,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -56309,7 +63875,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -56319,7 +63885,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -56329,7 +63895,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -56339,7 +63905,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -56349,7 +63915,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -56359,7 +63925,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -56369,7 +63935,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -56379,7 +63945,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -56389,7 +63955,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -56399,7 +63965,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -56409,7 +63975,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -56419,7 +63985,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -56439,7 +64005,7 @@
               "gameField": "bInfiniteDuration",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "The effect never expires on its own. It then only ends through one of the RemoveWhen... rules below, or by something cleansing it.",
               "guard": "SetInfiniteDuration"
             },
             {
@@ -56449,7 +64015,7 @@
               "gameField": "bTickWhenApplied",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ticks once the moment it is applied, rather than waiting for the turn to come round. Damage-over-time effects use this to hurt immediately.",
               "guard": "SetTickWhenApplied"
             },
             {
@@ -56459,7 +64025,7 @@
               "gameField": "bCanTickEveryAction",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ticks after every action the target takes rather than once a turn, where the character template supports it.",
               "guard": "SetCanTickEveryAction"
             },
             {
@@ -56469,7 +64035,7 @@
               "gameField": "bConvertTurnsToActions",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "When ticking per action, multiplies NumTurns by the actions available per turn, so a \"3 turn\" effect still lasts roughly three turns.",
               "guard": "SetConvertTurnsToActions"
             },
             {
@@ -56479,7 +64045,7 @@
               "gameField": "bRemoveWhenSourceDies",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Removes the effect when whoever applied it dies. Typical for effects sustained by their caster, such as mind control.",
               "guard": "SetRemoveWhenSourceDies"
             },
             {
@@ -56489,7 +64055,7 @@
               "gameField": "bRemoveWhenTargetDies",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Removes the effect when the affected unit dies, rather than leaving it on the body.",
               "guard": "SetRemoveWhenTargetDies"
             },
             {
@@ -56499,7 +64065,7 @@
               "gameField": "bRemoveWhenSourceDamaged",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Removes the effect as soon as the source takes damage, for concentration-style effects broken by being hit.",
               "guard": "SetRemoveWhenSourceDamaged"
             },
             {
@@ -56509,7 +64075,7 @@
               "gameField": "bRemoveWhenTargetConcealmentBroken",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Removes the effect when the target loses concealment. Used by effects that only make sense while hidden.",
               "guard": "SetRemoveWhenTargetConcealmentBroken"
             },
             {
@@ -56519,7 +64085,7 @@
               "gameField": "bPersistThroughTacticalGameEnd",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Keeps the effect on the unit after it leaves play, until the mission ends. Needed by effects that must still be read when the mission is scored.",
               "guard": "SetPersistThroughTacticalGameEnd"
             },
             {
@@ -56529,7 +64095,7 @@
               "gameField": "bIgnorePlayerCheckOnTick",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ticks regardless of whose turn it is. Normally an effect only ticks on its owner’s turn.",
               "guard": "SetIgnorePlayerCheckOnTick"
             },
             {
@@ -56539,7 +64105,7 @@
               "gameField": "bUniqueTarget",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only one target may carry this effect from a given source at a time; applying it elsewhere removes the earlier one.",
               "guard": "SetUniqueTarget"
             },
             {
@@ -56549,7 +64115,7 @@
               "gameField": "bStackOnRefresh",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Re-applying the effect increments a stack counter instead of simply refreshing its duration, so effects that grow with repetition can read the count.",
               "guard": "SetStackOnRefresh"
             },
             {
@@ -56559,7 +64125,7 @@
               "gameField": "bDupeForSameSourceOnly",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "When checking whether the target already has this effect, only consider copies from the same source. Lets several units apply their own instance.",
               "guard": "SetDupeForSameSourceOnly"
             },
             {
@@ -56569,7 +64135,7 @@
               "gameField": "bEffectForcesBleedout",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "A unit reduced to zero health while under this effect bleeds out instead of dying outright.",
               "guard": "SetEffectForcesBleedout"
             },
             {
@@ -56579,7 +64145,7 @@
               "gameField": "bDisplayInUI",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Whether the effect appears in the unit’s status UI at all. An effect with no FriendlyName set will show as blank.",
               "guard": "SetDisplayInUI"
             },
             {
@@ -56589,7 +64155,7 @@
               "gameField": "bDisplayInSpecialDamageMessageUI",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Shows FriendlyName in the damage feedback as a distinct source, so its damage reads separately from the weapon’s.",
               "guard": "SetDisplayInSpecialDamageMessageUI"
             },
             {
@@ -56599,7 +64165,7 @@
               "gameField": "bSourceDisplayInUI",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "As DisplayInUI, but for the unit that applied the effect rather than the one carrying it.",
               "guard": "SetSourceDisplayInUI"
             },
             {
@@ -56609,7 +64175,7 @@
               "gameField": "iNumTurns",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "How many turns the effect lasts. Ignored when InfiniteDuration is true.",
               "guard": "SetNumTurns"
             },
             {
@@ -56619,7 +64185,7 @@
               "gameField": "iInitialShedChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Percentage chance the effect is shed immediately on the first tick, before PerTurnShedChance takes over.",
               "guard": "SetInitialShedChance"
             },
             {
@@ -56629,7 +64195,7 @@
               "gameField": "iPerTurnShedChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Percentage chance per tick that the effect wears off early. 0 means it only ends when its turns run out.",
               "guard": "SetPerTurnShedChance"
             },
             {
@@ -56639,7 +64205,7 @@
               "gameField": "EffectRank",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Precedence among effects of the same kind, used by auras so a stronger source wins over a weaker one.",
               "guard": "SetEffectRank"
             },
             {
@@ -56649,7 +64215,7 @@
               "gameField": "EffectHierarchyValue",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Decides which effect controls the unit’s animation when several apply at once. The higher value wins.",
               "guard": "SetEffectHierarchyValue"
             },
             {
@@ -56659,7 +64225,7 @@
               "gameField": "VisionArcDegreesOverride",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Narrows the unit’s sight arc to this many degrees. When two effects both set it, the smaller arc applies.",
               "guard": "SetVisionArcDegreesOverride"
             },
             {
@@ -56669,7 +64235,7 @@
               "gameField": "CustomIdleOverrideAnim",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Idle animation to play while the effect is active, taking over the unit’s normal idle.",
               "guard": "SetCustomIdleOverrideAnim"
             },
             {
@@ -56679,7 +64245,7 @@
               "gameField": "EffectName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Identifier used when deciding how this effect stacks with others, and the name other effects use to find or remove it.",
               "guard": "SetEffectName"
             },
             {
@@ -56689,7 +64255,7 @@
               "gameField": "AbilitySourceName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Which ability this is presented as coming from. Controls how a passive buff is coloured in the HUD.",
               "guard": "SetAbilitySourceName"
             },
             {
@@ -56699,7 +64265,7 @@
               "gameField": "EffectAppliedEventName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Event fired when the effect is applied, for listeners and triggered abilities to react to.",
               "guard": "SetEffectAppliedEventName"
             },
             {
@@ -56709,7 +64275,7 @@
               "gameField": "ChanceEventTriggerName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Event fired when the per-turn shed-chance roll succeeds.",
               "guard": "SetChanceEventTriggerName"
             },
             {
@@ -56719,7 +64285,7 @@
               "gameField": "VFXSocket",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Socket on the unit’s skeleton to attach the particle system to.",
               "guard": "SetVFXSocket"
             },
             {
@@ -56729,7 +64295,7 @@
               "gameField": "VFXSocketsArrayName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Named array of sockets to attach the particle system to, for effects that appear in several places at once. Optional.",
               "guard": "SetVFXSocketsArrayName"
             },
             {
@@ -56739,7 +64305,7 @@
               "gameField": "FriendlyName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Name shown in the unit’s status UI.",
               "guard": "SetFriendlyName"
             },
             {
@@ -56749,7 +64315,7 @@
               "gameField": "FriendlyDescription",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Description shown beneath FriendlyName in the status UI.",
               "guard": "SetFriendlyDescription"
             },
             {
@@ -56759,7 +64325,7 @@
               "gameField": "IconImage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Path to the status icon shown in the UI.",
               "guard": "SetIconImage"
             },
             {
@@ -56769,7 +64335,7 @@
               "gameField": "SourceFriendlyName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Name shown on the unit that applied the effect, as opposed to the one carrying it.",
               "guard": "SetSourceFriendlyName"
             },
             {
@@ -56779,7 +64345,7 @@
               "gameField": "SourceFriendlyDescription",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Description shown on the applying unit.",
               "guard": "SetSourceFriendlyDescription"
             },
             {
@@ -56789,7 +64355,7 @@
               "gameField": "SourceIconLabel",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Short label drawn on the applying unit’s icon.",
               "guard": "SetSourceIconLabel"
             },
             {
@@ -56799,7 +64365,7 @@
               "gameField": "StatusIcon",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Path to the small status icon used in condensed UI, alongside IconImage.",
               "guard": "SetStatusIcon"
             },
             {
@@ -56809,7 +64375,7 @@
               "gameField": "VFXTemplateName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Particle system played on the unit for as long as the effect lasts.",
               "guard": "SetVFXTemplateName"
             },
             {
@@ -56819,7 +64385,7 @@
               "gameField": "PersistentPerkName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Perk effect played on the unit while this effect is active.",
               "guard": "SetPersistentPerkName"
             }
           ],
@@ -56920,7 +64486,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -56930,7 +64496,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -56940,7 +64506,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -56950,7 +64516,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -56960,7 +64526,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -56970,7 +64536,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -56980,7 +64546,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -56990,7 +64556,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -57000,7 +64566,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -57010,7 +64576,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -57020,7 +64586,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -57030,7 +64596,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -57040,7 +64606,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -57050,7 +64616,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -57060,7 +64626,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -57070,7 +64636,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -57080,7 +64646,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -57090,7 +64656,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -57100,7 +64666,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -57120,7 +64686,7 @@
               "gameField": "Amount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Turns taken off each cooldown.",
               "guard": "SetAmount"
             },
             {
@@ -57130,7 +64696,7 @@
               "gameField": "ReduceAll",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Clear the cooldowns entirely instead of reducing them by Amount.",
               "guard": "SetReduceAll"
             },
             {
@@ -57140,7 +64706,7 @@
               "gameField": "AbilitiesToTick",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Abilities whose cooldowns are reduced. Empty means every ability.",
               "modeField": "AbilitiesToTickMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -57161,7 +64727,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -57171,7 +64737,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -57181,7 +64747,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -57191,7 +64757,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -57201,7 +64767,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -57211,7 +64777,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -57221,7 +64787,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -57231,7 +64797,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -57241,7 +64807,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -57251,7 +64817,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -57261,7 +64827,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -57271,7 +64837,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -57281,7 +64847,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -57291,7 +64857,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -57301,7 +64867,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -57311,7 +64877,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -57321,7 +64887,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -57331,7 +64897,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -57341,7 +64907,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -57361,7 +64927,7 @@
               "gameField": "UnitDamageMultiplier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier on the damage the detonated object deals to units.",
               "guard": "SetUnitDamageMultiplier"
             },
             {
@@ -57371,7 +64937,7 @@
               "gameField": "DamageRadiusMultiplier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multiplier on the detonation's damage radius.",
               "guard": "SetDamageRadiusMultiplier"
             }
           ],
@@ -57391,7 +64957,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -57401,7 +64967,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -57411,7 +64977,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -57421,7 +64987,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -57431,7 +64997,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -57441,7 +65007,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -57451,7 +65017,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -57461,7 +65027,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -57471,7 +65037,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -57481,7 +65047,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -57491,7 +65057,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -57501,7 +65067,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -57511,7 +65077,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -57521,7 +65087,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -57531,7 +65097,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -57541,7 +65107,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -57551,7 +65117,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -57561,7 +65127,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -57571,7 +65137,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -57591,7 +65157,7 @@
               "gameField": "bCleanse",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Remove the effects as a cleanse, so whatever they do on wearing off does not trigger.",
               "guard": "SetCleanse"
             },
             {
@@ -57601,7 +65167,7 @@
               "gameField": "bCheckSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Match effects whose source is this effect's target, instead of effects whose target it is.",
               "guard": "SetCheckSource"
             },
             {
@@ -57611,7 +65177,7 @@
               "gameField": "bDoNotVisualize",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Skip the removal visualization, for when another RemoveEffects on the ability already shows it.",
               "guard": "SetDoNotVisualize"
             },
             {
@@ -57621,7 +65187,7 @@
               "gameField": "EffectNamesToRemove",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effect names removed from the target.",
               "modeField": "EffectNamesToRemoveMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -57642,7 +65208,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -57652,7 +65218,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -57662,7 +65228,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -57672,7 +65238,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -57682,7 +65248,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -57692,7 +65258,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -57702,7 +65268,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -57712,7 +65278,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -57722,7 +65288,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -57732,7 +65298,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -57742,7 +65308,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -57752,7 +65318,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -57762,7 +65328,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -57772,7 +65338,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -57782,7 +65348,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -57792,7 +65358,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -57802,7 +65368,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -57812,7 +65378,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -57822,7 +65388,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -57842,7 +65408,7 @@
               "gameField": "ReserveType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Type of action point reserved.",
               "guard": "SetReserveType"
             },
             {
@@ -57852,7 +65418,7 @@
               "gameField": "NumPoints",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Number of action points reserved.",
               "guard": "SetNumPoints"
             }
           ],
@@ -57872,7 +65438,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -57882,7 +65448,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -57892,7 +65458,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -57902,7 +65468,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -57912,7 +65478,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -57922,7 +65488,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -57932,7 +65498,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -57942,7 +65508,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -57952,7 +65518,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -57962,7 +65528,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -57972,7 +65538,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -57982,7 +65548,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -57992,7 +65558,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -58002,7 +65568,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -58012,7 +65578,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -58022,7 +65588,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -58032,7 +65598,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -58042,7 +65608,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -58052,7 +65618,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -58072,7 +65638,7 @@
               "gameField": "UnitName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value written.",
               "guard": "SetUnitName"
             },
             {
@@ -58082,7 +65648,7 @@
               "gameField": "NewValueToSet",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Value written to the unit value.",
               "guard": "SetNewValueToSet"
             },
             {
@@ -58092,7 +65658,7 @@
               "gameField": "CleanupType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "When the unit value is cleared: eCleanup_BeginTurn, eCleanup_BeginTactical, eCleanup_Never or eCleanup_BeginTacticalChain.",
               "guard": "SetCleanupType"
             }
           ],
@@ -58112,7 +65678,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -58122,7 +65688,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -58132,7 +65698,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -58142,7 +65708,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -58152,7 +65718,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -58162,7 +65728,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -58172,7 +65738,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -58182,7 +65748,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -58192,7 +65758,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -58202,7 +65768,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -58212,7 +65778,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -58222,7 +65788,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -58232,7 +65798,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -58242,7 +65808,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -58252,7 +65818,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -58262,7 +65828,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -58272,7 +65838,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -58282,7 +65848,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -58292,7 +65858,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -58312,12 +65878,17 @@
               "gameField": "UnitValueToRead",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value read to find how much health to steal.",
               "guard": "SetUnitValueToRead"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "HealedMessage",
+              "reason": "localized &mdash; use .int localization files"
+            }
+          ]
         },
         {
           "class": "X2AbilityEffectsEditor_Spotted",
@@ -58332,7 +65903,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -58342,7 +65913,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -58352,7 +65923,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -58362,7 +65933,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -58372,7 +65943,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -58382,7 +65953,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -58392,7 +65963,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -58402,7 +65973,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -58412,7 +65983,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -58422,7 +65993,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -58432,7 +66003,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -58442,7 +66013,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -58452,7 +66023,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -58462,7 +66033,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -58472,7 +66043,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -58482,7 +66053,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -58492,7 +66063,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -58502,7 +66073,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -58512,7 +66083,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -58532,7 +66103,7 @@
               "gameField": "m_bBecomeUnspotted",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Mark the unit as unspotted instead of spotted.",
               "guard": "SetBecomeUnspotted"
             }
           ],
@@ -58552,7 +66123,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -58562,7 +66133,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -58572,7 +66143,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -58582,7 +66153,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -58592,7 +66163,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -58602,7 +66173,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -58612,7 +66183,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -58622,7 +66193,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -58632,7 +66203,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -58642,7 +66213,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -58652,7 +66223,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -58662,7 +66233,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -58672,7 +66243,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -58682,7 +66253,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -58692,7 +66263,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -58702,7 +66273,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -58712,7 +66283,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -58722,7 +66293,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -58732,7 +66303,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -58752,7 +66323,7 @@
               "gameField": "bResumeMissionTimer",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Resume the mission timer instead of suspending it.",
               "guard": "SetResumeMissionTimer"
             }
           ],
@@ -58772,7 +66343,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -58782,7 +66353,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -58792,7 +66363,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -58802,7 +66373,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -58812,7 +66383,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -58822,7 +66393,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -58832,7 +66403,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -58842,7 +66413,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -58852,7 +66423,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -58862,7 +66433,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -58872,7 +66443,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -58882,7 +66453,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -58892,7 +66463,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -58902,7 +66473,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -58912,7 +66483,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -58922,7 +66493,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -58932,7 +66503,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -58942,7 +66513,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -58952,7 +66523,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -58972,7 +66543,7 @@
               "gameField": "TriggerEventName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Event the effect fires.",
               "guard": "SetTriggerEventName"
             },
             {
@@ -58982,7 +66553,7 @@
               "gameField": "PassTargetAsSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fire the event with the target as its source.",
               "guard": "SetPassTargetAsSource"
             }
           ],
@@ -59002,7 +66573,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -59012,7 +66583,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -59022,7 +66593,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -59032,7 +66603,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -59042,7 +66613,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -59052,7 +66623,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -59062,7 +66633,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -59072,7 +66643,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -59082,7 +66653,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -59092,7 +66663,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -59102,7 +66673,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -59112,7 +66683,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -59122,7 +66693,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -59132,7 +66703,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -59142,7 +66713,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -59152,7 +66723,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -59162,7 +66733,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -59172,7 +66743,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -59182,7 +66753,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59202,7 +66773,7 @@
               "gameField": "DamagePerAction",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Damage dealt for each action point stolen.",
               "guard": "SetDamagePerAction"
             },
             {
@@ -59212,7 +66783,7 @@
               "gameField": "HealthReturnMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fraction of the damage dealt that is returned to the source as health.",
               "guard": "SetHealthReturnMod"
             }
           ],
@@ -59232,7 +66803,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -59242,7 +66813,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -59252,7 +66823,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -59262,7 +66833,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -59272,7 +66843,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -59282,7 +66853,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -59292,7 +66863,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -59302,7 +66873,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -59312,7 +66883,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -59322,7 +66893,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -59332,7 +66903,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -59342,7 +66913,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -59352,7 +66923,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -59362,7 +66933,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -59372,7 +66943,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -59382,7 +66953,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -59392,7 +66963,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -59402,7 +66973,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -59412,7 +66983,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59432,7 +67003,7 @@
               "gameField": "bCenterTile",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Apply the world effect to the centre tile only.",
               "guard": "SetCenterTile"
             }
           ],
@@ -59452,7 +67023,7 @@
               "gameField": "bApplyOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied when the ability hits. Most effects want this true; setting it false is how an effect is made to trigger only on a miss.",
               "guard": "SetApplyOnHit"
             },
             {
@@ -59462,7 +67033,7 @@
               "gameField": "bApplyOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied even when the ability misses.",
               "guard": "SetApplyOnMiss"
             },
             {
@@ -59472,7 +67043,7 @@
               "gameField": "ApplyChance",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Percentage chance the effect applies at all, rolled per target. 0 behaves as \"always\", since the roll is only made when a chance is set.",
               "guard": "SetApplyChance"
             },
             {
@@ -59482,7 +67053,7 @@
               "gameField": "bApplyToWorldOnHit",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is applied to the world (tiles, cover, environment) on a hit, rather than to a unit. Used by fire, smoke, acid and the other world effects.",
               "guard": "SetApplyToWorldOnHit"
             },
             {
@@ -59492,7 +67063,7 @@
               "gameField": "bApplyToWorldOnMiss",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "As ApplyToWorldOnHit, but for a miss. Grenades typically set both, so they still affect the ground when they scatter.",
               "guard": "SetApplyToWorldOnMiss"
             },
             {
@@ -59502,7 +67073,7 @@
               "gameField": "bUseSourcePlayerState",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Records the source player on the effect when it is applied, so later logic can tell whose effect it was. Needed by effects that behave differently for XCOM and the AI.",
               "guard": "SetUseSourcePlayerState"
             },
             {
@@ -59512,7 +67083,7 @@
               "gameField": "bIsImpairing",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as impairing the unit, which fires the impairment event and makes the unit report as impaired. This is what stuns, panic and disorientation use.",
               "guard": "SetIsImpairing"
             },
             {
@@ -59522,7 +67093,7 @@
               "gameField": "bIsImpairingMomentarily",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Fires the impairment event without leaving the unit flagged as impaired afterwards. For effects that interrupt an action but do not linger.",
               "guard": "SetIsImpairingMomentarily"
             },
             {
@@ -59532,7 +67103,7 @@
               "gameField": "bBringRemoveVisualizationForward",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Moves this effect's removal visualization earlier in the sequence, taking the whole context's visualization with it. Used when a removal must be seen before what follows.",
               "guard": "SetBringRemoveVisualizationForward"
             },
             {
@@ -59542,7 +67113,7 @@
               "gameField": "bShowImmunity",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows a flyover when the target is immune to this effect. Only when the application actually failed because of immunity.",
               "guard": "SetShowImmunity"
             },
             {
@@ -59552,7 +67123,7 @@
               "gameField": "bShowImmunityAnyFailure",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Shows the immunity flyover whenever the effect fails to apply for any reason, not only immunity. Broader, and noisier, than ShowImmunity.",
               "guard": "SetShowImmunityAnyFailure"
             },
             {
@@ -59562,7 +67133,7 @@
               "gameField": "bAppliesDamage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Marks the effect as dealing damage, so it counts towards damage statistics and raises the generic ability-damage events. Set it on any custom source of damage.",
               "guard": "SetAppliesDamage"
             },
             {
@@ -59572,7 +67143,7 @@
               "gameField": "bCanBeRedirected",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Whether the effect is eligible to be redirected onto another target, by Untouchable, Bladestorm parries and similar. Leave false for effects that must hit their target.",
               "guard": "SetCanBeRedirected"
             },
             {
@@ -59582,7 +67153,7 @@
               "gameField": "bHideDeathWorldMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Suppresses the usual death message when this effect is what kills the unit, for deaths that should read as something other than a normal kill.",
               "guard": "SetHideDeathWorldMessage"
             },
             {
@@ -59592,7 +67163,7 @@
               "gameField": "MinStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "For effects resolved by a stat contest: the contest result must be at least this for the effect to apply. Used to band outcomes, so a stronger roll applies a stronger effect.",
               "guard": "SetMinStatContestResult"
             },
             {
@@ -59602,7 +67173,7 @@
               "gameField": "MaxStatContestResult",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Upper bound of the same stat-contest band. Ignored when it is below MinStatContestResult.",
               "guard": "SetMaxStatContestResult"
             },
             {
@@ -59612,7 +67183,7 @@
               "gameField": "DelayVisualizationSec",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Seconds to delay this effect's visualization, for sequencing it against the rest of the ability rather than changing any game state.",
               "guard": "SetDelayVisualizationSec"
             },
             {
@@ -59622,7 +67193,7 @@
               "gameField": "OverrideMissMessage",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Replaces the usual \"Miss\" flyover with your own text, for abilities where a miss should read as something else.",
               "guard": "SetOverrideMissMessage"
             },
             {
@@ -59632,7 +67203,7 @@
               "gameField": "DamageTypes",
               "origin": "base",
               "inheritedFrom": "X2AbilityEffectsEditor",
-              "description": "",
+              "description": "Damage types this effect counts as. A unit immune to any type listed here resists the effect, and cleansing effects look at these types to decide what they can remove.",
               "modeField": "DamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59668,6 +67239,7 @@
         "X2AbilityConditionEditor_EverVigilant",
         "X2AbilityConditionEditor_FuseTarget",
         "X2AbilityConditionEditor_GameplayTag",
+        "X2AbilityConditionEditor_GameTime",
         "X2AbilityConditionEditor_HackingTarget",
         "X2AbilityConditionEditor_Interactive",
         "X2AbilityConditionEditor_Lootable",
@@ -59708,7 +67280,7 @@
               "gameField": "ExcludeEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that reject the unit when present, each with the failure reason to return.",
               "modeField": "ExcludeEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59719,7 +67291,7 @@
               "gameField": "RequireEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that must all be present on the unit, each with the failure reason to return.",
               "modeField": "RequireEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -59740,7 +67312,7 @@
               "gameField": "ExcludeEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that reject the unit when present, each with the failure reason to return.",
               "modeField": "ExcludeEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59751,7 +67323,7 @@
               "gameField": "RequireEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that must all be present on the unit, each with the failure reason to return.",
               "modeField": "RequireEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -59772,7 +67344,7 @@
               "gameField": "ExcludeEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that reject the unit when present, each with the failure reason to return.",
               "modeField": "ExcludeEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59783,7 +67355,7 @@
               "gameField": "RequireEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that must all be present on the unit, each with the failure reason to return.",
               "modeField": "RequireEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -59804,7 +67376,7 @@
               "gameField": "ExcludeEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that reject the unit when present, each with the failure reason to return.",
               "modeField": "ExcludeEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -59815,7 +67387,7 @@
               "gameField": "RequireEffects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityConditionEditor_UnitEffects",
-              "description": "",
+              "description": "Effects that must all be present on the unit, each with the failure reason to return.",
               "modeField": "RequireEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -59836,7 +67408,7 @@
               "gameField": "TargetMustBeInValidTiles",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject targets standing outside the ability's valid tiles.",
               "guard": "SetTargetMustBeInValidTiles"
             },
             {
@@ -59846,7 +67418,7 @@
               "gameField": "OwnerHasSoldierAbilities",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Soldier abilities the unit owning the ability must have.",
               "modeField": "OwnerHasSoldierAbilitiesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -59867,7 +67439,7 @@
               "gameField": "WantsReload",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail with AA_AmmoAlreadyFull when the source weapon's clip is already full.",
               "guard": "SetWantsReload"
             },
             {
@@ -59877,7 +67449,7 @@
               "gameField": "CheckAmmo",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Compare the source weapon's ammo against CheckAmmoData.",
               "guard": "SetCheckAmmo"
             },
             {
@@ -59887,7 +67459,7 @@
               "gameField": "CheckAmmoData",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "The ammo check used when CheckAmmo is true: Value, CheckType, and ValueMin/ValueMax for range checks.",
               "guard": "SetCheckAmmoData"
             },
             {
@@ -59897,7 +67469,7 @@
               "gameField": "NotLoadedAmmoInSecondaryWeapon",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail when the source weapon is currently loaded as ammo in the secondary weapon.",
               "guard": "SetNotLoadedAmmoInSecondaryWeapon"
             },
             {
@@ -59907,7 +67479,7 @@
               "gameField": "MatchGrenadeType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Grenade template the source weapon, or its loaded ammo, must be.",
               "guard": "SetMatchGrenadeType"
             },
             {
@@ -59917,7 +67489,7 @@
               "gameField": "CheckGrenadeFriendlyFire",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject friendly targets unless the grenade template allows friendly fire.",
               "guard": "SetCheckGrenadeFriendlyFire"
             },
             {
@@ -59927,7 +67499,7 @@
               "gameField": "CheckAmmoTechLevel",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject the source ammo when it is not valid for the unit's primary weapon.",
               "guard": "SetCheckAmmoTechLevel"
             },
             {
@@ -59937,7 +67509,7 @@
               "gameField": "MatchWeaponTemplate",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Weapon template the source weapon must be, exact match on its DataName.",
               "guard": "SetMatchWeaponTemplate"
             }
           ],
@@ -59957,7 +67529,7 @@
               "gameField": "bMissionAborted",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the mission to have been aborted.",
               "guard": "SetMissionAborted"
             },
             {
@@ -59967,7 +67539,7 @@
               "gameField": "bMissionNotAborted",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the mission not to have been aborted.",
               "guard": "SetMissionNotAborted"
             },
             {
@@ -59977,7 +67549,7 @@
               "gameField": "bCiviliansTargetedByAliens",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a mission where aliens target civilians.",
               "guard": "SetCiviliansTargetedByAliens"
             },
             {
@@ -59987,7 +67559,7 @@
               "gameField": "bCiviliansNotTargetedByAliens",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a mission where aliens do not target civilians.",
               "guard": "SetCiviliansNotTargetedByAliens"
             },
             {
@@ -59997,7 +67569,7 @@
               "gameField": "bIncludeTheLostInEngagedCount",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Count the Lost among the engaged enemies.",
               "guard": "SetIncludeTheLostInEngagedCount"
             },
             {
@@ -60007,7 +67579,7 @@
               "gameField": "MinEngagedEnemies",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fewest engaged enemies required. -1 ignores it.",
               "guard": "SetMinEngagedEnemies"
             },
             {
@@ -60017,7 +67589,7 @@
               "gameField": "MaxEngagedEnemies",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Most engaged enemies allowed. -1 ignores it.",
               "guard": "SetMaxEngagedEnemies"
             }
           ],
@@ -60037,7 +67609,7 @@
               "gameField": "bFailOnNonUnitTargets",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail with AA_NotAUnit on non-unit targets instead of passing them through.",
               "guard": "SetFailOnNonUnitTargets"
             }
           ],
@@ -60057,7 +67629,7 @@
               "gameField": "MinBondLevel",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lowest bond level between the two units, inclusive.",
               "guard": "SetMinBondLevel"
             },
             {
@@ -60067,7 +67639,7 @@
               "gameField": "MaxBondLevel",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Highest bond level between the two units, inclusive.",
               "guard": "SetMaxBondLevel"
             },
             {
@@ -60077,7 +67649,7 @@
               "gameField": "RequiresAdjacency",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Whether the bondmates may, must not, or must be adjacent: EAR_AnyAdjacency, EAR_DisallowAdjacency or EAR_RequireAdjacency.",
               "guard": "SetRequiresAdjacency"
             },
             {
@@ -60087,7 +67659,7 @@
               "gameField": "bSkipCheckWithSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Only check that the source has a bondmate on the mission, not that the target is that bondmate. For self-targeted bondmate abilities.",
               "guard": "SetSkipCheckWithSource"
             }
           ],
@@ -60107,7 +67679,7 @@
               "gameField": "bStilettoRounds",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Pass only while the Stiletto Rounds dark event is active.",
               "guard": "SetStilettoRounds"
             }
           ],
@@ -60130,7 +67702,12 @@
           "catchAll": false,
           "fields": [],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "FuseAbilities",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityConditionEditor_GameplayTag",
@@ -60145,7 +67722,7 @@
               "gameField": "RequiredGameplayTag",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Tactical gameplay tag XCOM HQ must carry for the ability to be valid.",
               "guard": "SetRequiredGameplayTag"
             },
             {
@@ -60155,13 +67732,34 @@
               "gameField": "DisallowGameplayTag",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Tactical gameplay tag that makes the ability invalid while XCOM HQ carries it.",
               "guard": "SetDisallowGameplayTag"
             }
           ],
           "abstract": false,
           "notEditable": []
         },
+        {
+          "class": "X2AbilityConditionEditor_GameTime",
+          "extends": "X2AbilityConditionEditor_Base",
+          "gameClass": "X2Condition_GameTime",
+          "catchAll": false,
+          "fields": [
+            {
+              "config": "HourChecks",
+              "type": "array<CheckConfig>",
+              "kind": "namearray",
+              "gameField": "HourChecks",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Checks against the current hour of the day; the condition passes when any one of them does. Merge adds checks not already present.",
+              "modeField": "HourChecksMode",
+              "modeEnum": "ENameArrayEditMode"
+            }
+          ],
+          "abstract": false,
+          "notEditable": []
+        },
         {
           "class": "X2AbilityConditionEditor_HackingTarget",
           "extends": "X2AbilityConditionEditor_Base",
@@ -60175,7 +67773,7 @@
               "gameField": "bIntrusionProtocol",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Hack objects at range: needs gameplay visibility of the object instead of an adjacent interaction point.",
               "guard": "SetIntrusionProtocol"
             },
             {
@@ -60185,7 +67783,7 @@
               "gameField": "bHaywireProtocol",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Target units instead of objects: living, unhacked, robotic enemies the unit sees or has squadsight on.",
               "guard": "SetHaywireProtocol"
             },
             {
@@ -60195,7 +67793,7 @@
               "gameField": "RequiredAbilityName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ability the interactive object must expose. For hacking, empty accepts any object; for a normal interaction it must match exactly.",
               "guard": "SetRequiredAbilityName"
             },
             {
@@ -60205,7 +67803,7 @@
               "gameField": "bMustBeDoor",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the object to be a door.",
               "guard": "SetMustBeDoor"
             }
           ],
@@ -60225,7 +67823,7 @@
               "gameField": "InteractionType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Kind of interaction point the unit must be next to: eInteractionType_Normal or eInteractionType_Hack.",
               "guard": "SetInteractionType"
             },
             {
@@ -60235,7 +67833,7 @@
               "gameField": "RequiredAbilityName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ability the interactive object must expose. For hacking, empty accepts any object; for a normal interaction it must match exactly.",
               "guard": "SetRequiredAbilityName"
             }
           ],
@@ -60255,7 +67853,7 @@
               "gameField": "bRestrictRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the loot to be within LootableRange of the source.",
               "guard": "SetRestrictRange"
             },
             {
@@ -60265,7 +67863,7 @@
               "gameField": "LootableRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Maximum distance to the loot, in Unreal units, when RestrictRange is set. A tile is 96.",
               "guard": "SetLootableRange"
             }
           ],
@@ -60277,14 +67875,21 @@
           "extends": "X2AbilityConditionEditor_Base",
           "gameClass": "X2Condition_MapProperty",
           "catchAll": false,
-          "fields": [],
-          "abstract": false,
-          "notEditable": [
+          "fields": [
             {
-              "name": "AllowedBiomes",
-              "reason": "array of `string`"
+              "config": "AllowedBiomes",
+              "type": "array<string>",
+              "kind": "namearray",
+              "gameField": "AllowedBiomes",
+              "origin": "derived",
+              "inheritedFrom": null,
+              "description": "Map biomes the mission must be in, when non-empty.",
+              "modeField": "AllowedBiomesMode",
+              "modeEnum": "ENameArrayEditMode"
             }
-          ]
+          ],
+          "abstract": false,
+          "notEditable": []
         },
         {
           "class": "X2AbilityConditionEditor_OnGroundTile",
@@ -60299,7 +67904,7 @@
               "gameField": "NotAFloorTileTag",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Tag of tiles that must not count as ground.",
               "guard": "SetNotAFloorTileTag"
             }
           ],
@@ -60319,7 +67924,7 @@
               "gameField": "MaxPanicUnitsPerPod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Most units of an AI pod that may be panicked at once. 0 removes the limit.",
               "guard": "SetMaxPanicUnitsPerPod"
             }
           ],
@@ -60339,7 +67944,7 @@
               "gameField": "NumTurnsCheck",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Check against the number of turns the target's controlling player has taken.",
               "guard": "SetNumTurnsCheck"
             }
           ],
@@ -60359,7 +67964,7 @@
               "gameField": "HackAbilityName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Hack ability whose rewards the target must offer, e.g. FinalizeSKULLJACK.",
               "guard": "SetHackAbilityName"
             }
           ],
@@ -60388,7 +67993,7 @@
               "gameField": "bCheckFlanking",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail when any enemy flanks the unit.",
               "guard": "SetCheckFlanking"
             }
           ],
@@ -60408,7 +68013,7 @@
               "gameField": "RequireVisible",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a free neighbouring tile the unit could be pulled to, rather than any free neighbouring tile.",
               "guard": "SetRequireVisible"
             }
           ],
@@ -60428,7 +68033,7 @@
               "gameField": "m_aCheckValues",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Action point checks; passes when any one of them does. Each names an action point type, whether to count reserved points, and the value check.",
               "modeField": "ActionPointChecksMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -60449,7 +68054,7 @@
               "gameField": "RequiredAlertStatusMaximum",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Highest alert level the unit may have. -1 ignores it; the condition fails when both limits are -1.",
               "guard": "SetRequiredAlertStatusMaximum"
             },
             {
@@ -60459,7 +68064,7 @@
               "gameField": "RequiredAlertStatusMinimum",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lowest alert level the unit may have. -1 ignores it; the condition fails when both limits are -1.",
               "guard": "SetRequiredAlertStatusMinimum"
             }
           ],
@@ -60479,7 +68084,7 @@
               "gameField": "ExcludeEffects",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effects that reject the unit when present, each with the failure reason to return.",
               "modeField": "ExcludeEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -60490,7 +68095,7 @@
               "gameField": "RequireEffects",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Effects that must all be present on the unit, each with the failure reason to return.",
               "modeField": "RequireEffectsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -60511,7 +68116,7 @@
               "gameField": "bOnlyOnCharacterTemplate",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Consider only the immunities of the unit's character template, not those granted by effects.",
               "guard": "SetOnlyOnCharacterTemplate"
             },
             {
@@ -60521,7 +68126,7 @@
               "gameField": "ExcludeDamageTypes",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Damage types; a unit immune to any of them is rejected.",
               "modeField": "ExcludeDamageTypesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -60551,7 +68156,7 @@
               "gameField": "InteractionType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Kind of interaction point the unit must be next to: eInteractionType_Normal or eInteractionType_Hack.",
               "guard": "SetInteractionType"
             }
           ],
@@ -60571,7 +68176,7 @@
               "gameField": "RelevantSlot",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Inventory slot whose item is checked.",
               "guard": "SetRelevantSlot"
             },
             {
@@ -60581,7 +68186,7 @@
               "gameField": "ExcludeWeaponCategory",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Weapon category that rejects the unit when the item in RelevantSlot has it.",
               "guard": "SetExcludeWeaponCategory"
             },
             {
@@ -60591,7 +68196,7 @@
               "gameField": "RequireWeaponCategory",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Weapon category the item in RelevantSlot must have. Fails when the slot is empty.",
               "guard": "SetRequireWeaponCategory"
             }
           ],
@@ -60611,7 +68216,7 @@
               "gameField": "ExcludeAlive",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject living units.",
               "guard": "SetExcludeAlive"
             },
             {
@@ -60621,7 +68226,7 @@
               "gameField": "ExcludeDead",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject dead units.",
               "guard": "SetExcludeDead"
             },
             {
@@ -60631,7 +68236,7 @@
               "gameField": "ExcludeRobotic",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject robotic units.",
               "guard": "SetExcludeRobotic"
             },
             {
@@ -60641,7 +68246,7 @@
               "gameField": "ExcludeOrganic",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject organic units.",
               "guard": "SetExcludeOrganic"
             },
             {
@@ -60651,7 +68256,7 @@
               "gameField": "ExcludeCivilian",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units whose character template is civilian, whatever their team.",
               "guard": "SetExcludeCivilian"
             },
             {
@@ -60661,7 +68266,7 @@
               "gameField": "ExcludeNonCivilian",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units whose character template is not civilian, whatever their team.",
               "guard": "SetExcludeNonCivilian"
             },
             {
@@ -60671,7 +68276,7 @@
               "gameField": "ExcludeCosmetic",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject cosmetic units, such as Gremlins.",
               "guard": "SetExcludeCosmetic"
             },
             {
@@ -60681,7 +68286,7 @@
               "gameField": "ExcludeImpaired",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject impaired units.",
               "guard": "SetExcludeImpaired"
             },
             {
@@ -60691,7 +68296,7 @@
               "gameField": "ExcludePanicked",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject panicked units.",
               "guard": "SetExcludePanicked"
             },
             {
@@ -60701,7 +68306,7 @@
               "gameField": "ExcludeInStasis",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units in stasis.",
               "guard": "SetExcludeInStasis"
             },
             {
@@ -60711,7 +68316,7 @@
               "gameField": "ExcludeTurret",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject turrets.",
               "guard": "SetExcludeTurret"
             },
             {
@@ -60721,7 +68326,7 @@
               "gameField": "ExcludePsionic",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject psionic units.",
               "guard": "SetExcludePsionic"
             },
             {
@@ -60731,7 +68336,7 @@
               "gameField": "ExcludeNonPsionic",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject non-psionic units.",
               "guard": "SetExcludeNonPsionic"
             },
             {
@@ -60741,7 +68346,7 @@
               "gameField": "IsAdvent",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require an ADVENT unit.",
               "guard": "SetIsAdvent"
             },
             {
@@ -60751,7 +68356,7 @@
               "gameField": "ExcludeAdvent",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject ADVENT units.",
               "guard": "SetExcludeAdvent"
             },
             {
@@ -60761,7 +68366,7 @@
               "gameField": "ExcludeNoCover",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units that are not in cover.",
               "guard": "SetExcludeNoCover"
             },
             {
@@ -60771,7 +68376,7 @@
               "gameField": "ExcludeNoCoverToSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units with no cover between them and the source.",
               "guard": "SetExcludeNoCoverToSource"
             },
             {
@@ -60781,7 +68386,7 @@
               "gameField": "ExcludeFullHealth",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units at full HP, unless a persistent damage effect listed in MedikitHealEffectTypes is on them.",
               "guard": "SetExcludeFullHealth"
             },
             {
@@ -60791,7 +68396,7 @@
               "gameField": "IsBleedingOut",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit that is bleeding out.",
               "guard": "SetIsBleedingOut"
             },
             {
@@ -60801,7 +68406,7 @@
               "gameField": "IsUnspotted",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit that has not been spotted.",
               "guard": "SetIsUnspotted"
             },
             {
@@ -60811,7 +68416,7 @@
               "gameField": "CanBeCarried",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit that can be carried.",
               "guard": "SetCanBeCarried"
             },
             {
@@ -60821,7 +68426,7 @@
               "gameField": "IsOutdoors",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit standing outdoors.",
               "guard": "SetIsOutdoors"
             },
             {
@@ -60831,7 +68436,7 @@
               "gameField": "IsConcealed",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a concealed unit.",
               "guard": "SetIsConcealed"
             },
             {
@@ -60841,7 +68446,7 @@
               "gameField": "ExcludeConcealed",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject concealed units. Only applies to the check without a source; visibility rules normally cover this.",
               "guard": "SetExcludeConcealed"
             },
             {
@@ -60851,7 +68456,7 @@
               "gameField": "IsSuperConcealed",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit in super concealment.",
               "guard": "SetIsSuperConcealed"
             },
             {
@@ -60861,7 +68466,7 @@
               "gameField": "IsImpaired",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require an impaired unit.",
               "guard": "SetIsImpaired"
             },
             {
@@ -60871,7 +68476,7 @@
               "gameField": "HasClearanceToMaxZ",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require open space above the unit up to the map ceiling.",
               "guard": "SetHasClearanceToMaxZ"
             },
             {
@@ -60881,7 +68486,7 @@
               "gameField": "ExcludeAlien",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject alien units.",
               "guard": "SetExcludeAlien"
             },
             {
@@ -60891,7 +68496,7 @@
               "gameField": "ExcludeNonHumanoidAliens",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject aliens that are not humanoid.",
               "guard": "SetExcludeNonHumanoidAliens"
             },
             {
@@ -60901,7 +68506,7 @@
               "gameField": "ExcludeStunned",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject stunned units.",
               "guard": "SetExcludeStunned"
             },
             {
@@ -60911,7 +68516,7 @@
               "gameField": "ExcludeDazed",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject dazed units.",
               "guard": "SetExcludeDazed"
             },
             {
@@ -60921,7 +68526,7 @@
               "gameField": "ExcludeUnableToAct",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units that are unable to act.",
               "guard": "SetExcludeUnableToAct"
             },
             {
@@ -60931,7 +68536,7 @@
               "gameField": "IsPlayerControlled",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a player-controlled unit.",
               "guard": "SetIsPlayerControlled"
             },
             {
@@ -60941,7 +68546,7 @@
               "gameField": "ExcludeUnrevealedAI",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject AI units that have not been revealed yet.",
               "guard": "SetExcludeUnrevealedAI"
             },
             {
@@ -60951,7 +68556,7 @@
               "gameField": "IncludeWeakAgainstTechLikeRobot",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Treat units flagged as weak against tech as robotic for the robotic checks.",
               "guard": "SetIncludeWeakAgainstTechLikeRobot"
             },
             {
@@ -60961,7 +68566,7 @@
               "gameField": "ImpairedIgnoresStuns",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Do not count stuns when deciding whether a unit is impaired.",
               "guard": "SetImpairedIgnoresStuns"
             },
             {
@@ -60971,7 +68576,7 @@
               "gameField": "IsScampering",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit that is currently scampering.",
               "guard": "SetIsScampering"
             },
             {
@@ -60981,7 +68586,7 @@
               "gameField": "ExcludeDeadFromSpecialDeath",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units killed by a special death.",
               "guard": "SetExcludeDeadFromSpecialDeath"
             },
             {
@@ -60991,7 +68596,7 @@
               "gameField": "ExcludeLargeUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units larger than one tile.",
               "guard": "SetExcludeLargeUnits"
             },
             {
@@ -61001,7 +68606,7 @@
               "gameField": "ImpairedIgnoresImpairingMomentarily",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Do not count momentary impairment when deciding whether a unit is impaired.",
               "guard": "SetImpairedIgnoresImpairingMomentarily"
             },
             {
@@ -61011,7 +68616,7 @@
               "gameField": "ExcludeHostileToSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units hostile to the source.",
               "guard": "SetExcludeHostileToSource"
             },
             {
@@ -61021,7 +68626,7 @@
               "gameField": "ExcludeFriendlyToSource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units friendly to the source.",
               "guard": "SetExcludeFriendlyToSource"
             },
             {
@@ -61031,7 +68636,7 @@
               "gameField": "TreatMindControlledSquadmateAsHostile",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Count a mind-controlled squadmate as hostile rather than friendly.",
               "guard": "SetTreatMindControlledSquadmateAsHostile"
             },
             {
@@ -61041,7 +68646,7 @@
               "gameField": "ExcludeSquadmates",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Reject units on the same team as the source.",
               "guard": "SetExcludeSquadmates"
             },
             {
@@ -61051,7 +68656,7 @@
               "gameField": "RequireSquadmates",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the unit to be on the same team as the source.",
               "guard": "SetRequireSquadmates"
             },
             {
@@ -61061,7 +68666,7 @@
               "gameField": "RequireWithinRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the unit to be within WithinRange of the source.",
               "guard": "SetRequireWithinRange"
             },
             {
@@ -61071,7 +68676,7 @@
               "gameField": "RequireWithinMinRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the unit to be within WithinMinRange of the source.",
               "guard": "SetRequireWithinMinRange"
             },
             {
@@ -61081,7 +68686,7 @@
               "gameField": "BeingCarriedBySource",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit currently carried by the source.",
               "guard": "SetBeingCarriedBySource"
             },
             {
@@ -61091,7 +68696,7 @@
               "gameField": "RequireUnitSelectedFromHQ",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require a unit that was selected from Headquarters for the mission. XCOM only.",
               "guard": "SetRequireUnitSelectedFromHQ"
             },
             {
@@ -61101,7 +68706,7 @@
               "gameField": "FailOnNonUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail with AA_NotAUnit on non-unit targets instead of passing them through.",
               "guard": "SetFailOnNonUnits"
             },
             {
@@ -61111,7 +68716,7 @@
               "gameField": "MinRank",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lowest soldier rank allowed.",
               "guard": "SetMinRank"
             },
             {
@@ -61121,7 +68726,7 @@
               "gameField": "MaxRank",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Highest soldier rank allowed.",
               "guard": "SetMaxRank"
             },
             {
@@ -61131,7 +68736,7 @@
               "gameField": "WithinRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Maximum distance between source and target, in Unreal units. A tile is 96.",
               "guard": "SetWithinRange"
             },
             {
@@ -61141,7 +68746,7 @@
               "gameField": "WithinMinRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Distance for the minimum-range check, in Unreal units. A tile is 96.",
               "guard": "SetWithinMinRange"
             },
             {
@@ -61151,7 +68756,7 @@
               "gameField": "ExcludeSoldierClasses",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Soldier classes that reject the unit. Non-soldiers always pass.",
               "modeField": "ExcludeSoldierClassesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -61162,7 +68767,7 @@
               "gameField": "RequireSoldierClasses",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Soldier classes the unit must be one of, when non-empty. Non-soldiers always fail.",
               "modeField": "RequireSoldierClassesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -61183,7 +68788,7 @@
               "gameField": "m_aCheckStats",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Stat checks that must all pass: the stat, the value check, and whether to compare as a percentage of the stat's maximum.",
               "modeField": "CheckStatsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -61204,7 +68809,7 @@
               "gameField": "IncludeTypes",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Character groups the unit must belong to, when non-empty. Takes precedence over ExcludeTypes.",
               "modeField": "IncludeTypesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -61215,7 +68820,7 @@
               "gameField": "ExcludeTypes",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Character groups that reject the unit. Ignored while IncludeTypes is non-empty.",
               "modeField": "ExcludeTypesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -61236,7 +68841,7 @@
               "gameField": "m_aCheckValues",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Unit value checks that must all pass: the value name, the value check, and an optional failure code to return instead of the default.",
               "modeField": "CheckValuesMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -61257,7 +68862,7 @@
               "gameField": "bNoEnemyViewers",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail when any enemy can see the target.",
               "guard": "SetNoEnemyViewers"
             },
             {
@@ -61267,7 +68872,7 @@
               "gameField": "bRequireMatchCoverType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the target to be in the cover type given by TargetCover.",
               "guard": "SetRequireMatchCoverType"
             },
             {
@@ -61277,7 +68882,7 @@
               "gameField": "bRequireNotMatchCoverType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the target not to be in the cover type given by TargetCover.",
               "guard": "SetRequireNotMatchCoverType"
             },
             {
@@ -61287,7 +68892,7 @@
               "gameField": "TargetCover",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Cover type used by RequireMatchCoverType and RequireNotMatchCoverType.",
               "guard": "SetTargetCover"
             },
             {
@@ -61297,7 +68902,7 @@
               "gameField": "bCannotPeek",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require the shooter to see the target from its own tile, without peeking.",
               "guard": "SetCannotPeek"
             },
             {
@@ -61307,7 +68912,7 @@
               "gameField": "bRequireLOS",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require line of sight.",
               "guard": "SetRequireLOS"
             },
             {
@@ -61317,7 +68922,7 @@
               "gameField": "bRequireBasicVisibility",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require line of sight and range.",
               "guard": "SetRequireBasicVisibility"
             },
             {
@@ -61327,7 +68932,7 @@
               "gameField": "bRequireGameplayVisible",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Require line of sight, range and the situational gameplay-visibility rules.",
               "guard": "SetRequireGameplayVisible"
             },
             {
@@ -61337,7 +68942,7 @@
               "gameField": "bAllowSquadsight",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Accept any squadmate's view of the target if the unit has Squadsight. Overrides RequireGameplayVisible.",
               "guard": "SetAllowSquadsight"
             },
             {
@@ -61347,7 +68952,7 @@
               "gameField": "bActAsSquadsight",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Accept any squadmate's view of the target whether or not the unit has Squadsight. Overrides RequireGameplayVisible.",
               "guard": "SetActAsSquadsight"
             },
             {
@@ -61357,7 +68962,7 @@
               "gameField": "bVisibleToAnyAlly",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Accept the target when any squadmate can see it, without line of sight from the unit itself. Overrides RequireGameplayVisible.",
               "guard": "SetVisibleToAnyAlly"
             },
             {
@@ -61367,7 +68972,7 @@
               "gameField": "bDisablePeeksOnMovement",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Forbid peeking once the target has moved.",
               "guard": "SetDisablePeeksOnMovement"
             },
             {
@@ -61377,7 +68982,7 @@
               "gameField": "bExcludeGameplayVisible",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fail when the target has gameplay visibility of the source.",
               "guard": "SetExcludeGameplayVisible"
             },
             {
@@ -61387,7 +68992,7 @@
               "gameField": "RequireGameplayVisibleTags",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Visibility tags that must be present on the visibility info, such as concealed or stealthed.",
               "modeField": "RequireGameplayVisibleTagsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -61446,7 +69051,7 @@
               "gameField": "AttackerStat",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Attacker's stat in a unit-versus-unit contest.",
               "guard": "SetAttackerStat"
             },
             {
@@ -61456,7 +69061,7 @@
               "gameField": "DefenderStat",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Defender's stat in a unit-versus-unit contest.",
               "guard": "SetDefenderStat"
             },
             {
@@ -61466,7 +69071,7 @@
               "gameField": "BaseValue",
               "origin": "derived",
               "inheritedFrom": "X2AbilityToHitCalcEditor_StatCheck",
-              "description": "",
+              "description": "Base value the stat contest is measured against.",
               "guard": "SetBaseValue"
             }
           ],
@@ -61496,7 +69101,7 @@
               "gameField": "FocusMultiplier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Percentage points added to the hit chance per point of Templar focus.",
               "guard": "SetFocusMultiplier"
             },
             {
@@ -61506,7 +69111,7 @@
               "gameField": "PercentToHit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityToHitCalcEditor_PercentChance",
-              "description": "",
+              "description": "Flat percentage chance to hit, ignoring aim entirely. For abilities whose odds are fixed rather than calculated.",
               "guard": "SetPercentToHit"
             },
             {
@@ -61516,7 +69121,7 @@
               "gameField": "bNoGameStateOnMiss",
               "origin": "derived",
               "inheritedFrom": "X2AbilityToHitCalcEditor_PercentChance",
-              "description": "",
+              "description": "Produces no game state at all on a miss, so nothing is recorded or visualised.",
               "guard": "SetNoGameStateOnMiss"
             }
           ],
@@ -61546,7 +69151,7 @@
               "gameField": "PercentToHitInBuddyZone",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Replaces PercentToHit when the target is inside the buddy zone.",
               "guard": "SetPercentToHitInBuddyZone"
             },
             {
@@ -61556,7 +69161,7 @@
               "gameField": "PercentToHit",
               "origin": "derived",
               "inheritedFrom": "X2AbilityToHitCalcEditor_PercentChance",
-              "description": "",
+              "description": "Flat percentage chance to hit, ignoring aim entirely. For abilities whose odds are fixed rather than calculated.",
               "guard": "SetPercentToHit"
             },
             {
@@ -61566,7 +69171,7 @@
               "gameField": "bNoGameStateOnMiss",
               "origin": "derived",
               "inheritedFrom": "X2AbilityToHitCalcEditor_PercentChance",
-              "description": "",
+              "description": "Produces no game state at all on a miss, so nothing is recorded or visualised.",
               "guard": "SetNoGameStateOnMiss"
             }
           ],
@@ -61596,7 +69201,7 @@
               "gameField": "bIndirectFire",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Treats the attack as indirect, like a grenade: it always hits, though crit, dodge and armour mitigation still apply.",
               "guard": "SetIndirectFire"
             },
             {
@@ -61606,7 +69211,7 @@
               "gameField": "bMeleeAttack",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Treats the attack as melee, which ignores cover and applies the intrinsic melee hit bonus.",
               "guard": "SetMeleeAttack"
             },
             {
@@ -61616,7 +69221,7 @@
               "gameField": "bReactionFire",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Treats the attack as reaction fire, which takes the reaction penalty and forgoes the flanking bonus.",
               "guard": "SetReactionFire"
             },
             {
@@ -61626,7 +69231,7 @@
               "gameField": "bAllowCrit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Whether crits are built into the hit table at all. Turning it off makes the ability incapable of critting.",
               "guard": "SetAllowCrit"
             },
             {
@@ -61636,7 +69241,7 @@
               "gameField": "bHitsAreCrits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Converts every successful hit into a crit after the roll is made.",
               "guard": "SetHitsAreCrits"
             },
             {
@@ -61646,7 +69251,7 @@
               "gameField": "bMultiTargetOnly",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Guarantees success when the ability has no primary target, for abilities that only ever hit multi-targets.",
               "guard": "SetMultiTargetOnly"
             },
             {
@@ -61656,7 +69261,7 @@
               "gameField": "bOnlyMultiHitWithSuccess",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Multi-target hits only land if the roll succeeded, as with Faceoff.",
               "guard": "SetOnlyMultiHitWithSuccess"
             },
             {
@@ -61666,7 +69271,7 @@
               "gameField": "bGuaranteedHit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Always hits, skipping the normal hit modifiers. Armour mitigation still rolls.",
               "guard": "SetGuaranteedHit"
             },
             {
@@ -61676,7 +69281,7 @@
               "gameField": "bIgnoreCoverBonus",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Ignores the target's high and low cover bonuses.",
               "guard": "SetIgnoreCoverBonus"
             },
             {
@@ -61686,7 +69291,7 @@
               "gameField": "FinalMultiplier",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Scales the final hit chance after everything else. Appears in the shot breakdown attributed to the ability.",
               "guard": "SetFinalMultiplier"
             },
             {
@@ -61696,7 +69301,7 @@
               "gameField": "BuiltInHitMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Flat aim modifier the ability always carries.",
               "guard": "SetBuiltInHitMod"
             },
             {
@@ -61706,12 +69311,125 @@
               "gameField": "BuiltInCritMod",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Flat crit modifier the ability always carries.",
               "guard": "SetBuiltInCritMod"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "SHOULD_ENABLE_PENALTY_ON_ANGLE_TO_EXTENDED_HIGH_COVER",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "SHOULD_DISABLE_BONUS_ON_ANGLE_TO_EXTENDED_LOW_COVER",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MAX_TILE_DISTANCE_TO_COVER",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MIN_ANGLE_TO_COVER",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MAX_ANGLE_TO_COVER",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MIN_ANGLE_BONUS_MOD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MAX_ANGLE_BONUS_MOD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MIN_ANGLE_PENALTY",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MAX_ANGLE_PENALTY",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "LOW_COVER_BONUS",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "HIGH_COVER_BONUS",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MP_FLANKING_CRIT_BONUS",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MELEE_HIT_BONUS",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "SQUADSIGHT_CRIT_MOD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "SQUADSIGHT_DISTANCE_MOD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "REACTION_FINALMOD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "REACTION_DASHING_FINALMOD",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "NormalSquadSize",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "ReasonableShotMinimumToEnableAimAssist",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MaxAimAssistScore",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "BaseXComHitChanceModifier",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "MissStreakChanceAdjustment",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "HitStreakChanceAdjustment",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "SoldiersLostXComHitChanceAdjustment",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "SoldiersLostAlienHitChanceAdjustment",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "AlienVsTheLostHitChanceAdjustment",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "TheLostVsAlienHitChanceAdjustment",
+              "reason": "config &mdash; tune it in the game's own ini"
+            },
+            {
+              "name": "CritUpgradesThatDontUseEffects",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityToHitCalcEditor_PercentChance",
@@ -61736,7 +69454,7 @@
               "gameField": "PercentToHit",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Flat percentage chance to hit, ignoring aim entirely. For abilities whose odds are fixed rather than calculated.",
               "guard": "SetPercentToHit"
             },
             {
@@ -61746,7 +69464,7 @@
               "gameField": "bNoGameStateOnMiss",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Produces no game state at all on a miss, so nothing is recorded or visualised.",
               "guard": "SetNoGameStateOnMiss"
             }
           ],
@@ -61776,12 +69494,17 @@
               "gameField": "bAlwaysSucceed",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Makes the hack always succeed.",
               "guard": "SetAlwaysSucceed"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "SKULLJACK_HACKING_BONUS",
+              "reason": "config &mdash; tune it in the game's own ini"
+            }
+          ]
         },
         {
           "class": "X2AbilityToHitCalcEditor_RollStat",
@@ -61806,7 +69529,7 @@
               "gameField": "StatToRoll",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Which unit stat the roll is made against.",
               "guard": "SetStatToRoll"
             },
             {
@@ -61816,7 +69539,7 @@
               "gameField": "BaseChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Base percentage before the stat is taken into account.",
               "guard": "SetBaseChance"
             }
           ],
@@ -61846,12 +69569,17 @@
               "gameField": "StatToRoll",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Which unit stat the roll is made against.",
               "guard": "SetStatToRoll"
             }
           ],
           "abstract": false,
-          "notEditable": []
+          "notEditable": [
+            {
+              "name": "StatContestTiers",
+              "reason": "private/protected"
+            }
+          ]
         },
         {
           "class": "X2AbilityToHitCalcEditor_StatCheck",
@@ -61876,7 +69604,7 @@
               "gameField": "BaseValue",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Base value the stat contest is measured against.",
               "guard": "SetBaseValue"
             }
           ],
@@ -61929,7 +69657,7 @@
               "gameField": "MovementRangeAdjustment",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Tiles added to or removed from how far the unit may move to reach a melee target.",
               "guard": "SetMovementRangeAdjustment"
             },
             {
@@ -61939,7 +69667,7 @@
               "gameField": "OnlyIncludeTargetsInsideWeaponRange",
               "origin": "derived",
               "inheritedFrom": "X2AbilityTargetStyleEditor_Single",
-              "description": "",
+              "description": "Excludes targets beyond the weapon's range from selection.",
               "guard": "SetOnlyIncludeTargetsInsideWeaponRange"
             },
             {
@@ -61949,7 +69677,7 @@
               "gameField": "bAllowInteractiveObjects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityTargetStyleEditor_Single",
-              "description": "",
+              "description": "Lets the ability target interactive objects such as doors and consoles.",
               "guard": "SetAllowInteractiveObjects"
             },
             {
@@ -61959,7 +69687,7 @@
               "gameField": "bAllowDestructibleObjects",
               "origin": "derived",
               "inheritedFrom": "X2AbilityTargetStyleEditor_Single",
-              "description": "",
+              "description": "Lets the ability target destructible scenery.",
               "guard": "SetAllowDestructibleObjects"
             },
             {
@@ -61969,7 +69697,7 @@
               "gameField": "bIncludeSelf",
               "origin": "derived",
               "inheritedFrom": "X2AbilityTargetStyleEditor_Single",
-              "description": "",
+              "description": "Lets the user target itself.",
               "guard": "SetIncludeSelf"
             },
             {
@@ -61979,7 +69707,7 @@
               "gameField": "bShowAOE",
               "origin": "derived",
               "inheritedFrom": "X2AbilityTargetStyleEditor_Single",
-              "description": "",
+              "description": "Draws the area-of-effect preview while aiming.",
               "guard": "SetShowAOE"
             }
           ],
@@ -61999,7 +69727,7 @@
               "gameField": "OnlyIncludeTargetsInsideWeaponRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Excludes targets beyond the weapon's range from selection.",
               "guard": "SetOnlyIncludeTargetsInsideWeaponRange"
             },
             {
@@ -62009,7 +69737,7 @@
               "gameField": "bAllowInteractiveObjects",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lets the ability target interactive objects such as doors and consoles.",
               "guard": "SetAllowInteractiveObjects"
             },
             {
@@ -62019,7 +69747,7 @@
               "gameField": "bAllowDestructibleObjects",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lets the ability target destructible scenery.",
               "guard": "SetAllowDestructibleObjects"
             },
             {
@@ -62029,7 +69757,7 @@
               "gameField": "bIncludeSelf",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lets the user target itself.",
               "guard": "SetIncludeSelf"
             },
             {
@@ -62039,7 +69767,7 @@
               "gameField": "bShowAOE",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Draws the area-of-effect preview while aiming.",
               "guard": "SetShowAOE"
             }
           ],
@@ -62059,7 +69787,7 @@
               "gameField": "bRestrictToWeaponRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Limits the cursor to the weapon's range.",
               "guard": "SetRestrictToWeaponRange"
             },
             {
@@ -62069,7 +69797,7 @@
               "gameField": "IncreaseWeaponRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra range in tiles beyond the weapon's own, when restricted to weapon range.",
               "guard": "SetIncreaseWeaponRange"
             },
             {
@@ -62079,7 +69807,7 @@
               "gameField": "bRestrictToSquadsightRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Limits the cursor to squadsight range rather than the weapon's.",
               "guard": "SetRestrictToSquadsightRange"
             },
             {
@@ -62089,7 +69817,7 @@
               "gameField": "FixedAbilityRange",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Fixed range in tiles, ignoring the weapon entirely.",
               "guard": "SetFixedAbilityRange"
             }
           ],
@@ -62135,7 +69863,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -62145,7 +69873,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -62155,7 +69883,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -62165,7 +69893,7 @@
               "gameField": "ConeEndDiameter",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Width of the cone at its far end, in metres.",
               "guard": "SetConeEndDiameter"
             },
             {
@@ -62175,7 +69903,7 @@
               "gameField": "ConeLength",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "How far the cone reaches, in metres.",
               "guard": "SetConeLength"
             },
             {
@@ -62185,7 +69913,7 @@
               "gameField": "bUseWeaponRangeForLength",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Takes the cone's length from the weapon's range instead of ConeLength.",
               "guard": "SetUseWeaponRangeForLength"
             },
             {
@@ -62195,7 +69923,7 @@
               "gameField": "bLockShooterZ",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Restricts the cone to tiles at the shooter's own height, so it does not spread up or down floors.",
               "guard": "SetLockShooterZ"
             },
             {
@@ -62205,7 +69933,7 @@
               "gameField": "AbilityBonusCones",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra cone length and width granted by a particular ability, merged by RequiredAbility.",
               "modeField": "AbilityBonusConesMode",
               "modeEnum": "ENameArrayEditMode"
             },
@@ -62216,7 +69944,7 @@
               "gameField": "bUseWeaponRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the radius from the weapon. TargetRadius is then added on top.",
               "guard": "SetUseWeaponRadius"
             },
             {
@@ -62226,7 +69954,7 @@
               "gameField": "bUseWeaponBlockingCoverFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the weapon's setting for whether cover blocks the area.",
               "guard": "SetUseWeaponBlockingCoverFlag"
             },
             {
@@ -62236,7 +69964,7 @@
               "gameField": "bIgnoreBlockingCover",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Lets the area pass through cover that would otherwise block it.",
               "guard": "SetIgnoreBlockingCover"
             },
             {
@@ -62246,7 +69974,7 @@
               "gameField": "fTargetRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.",
               "guard": "SetTargetRadius"
             },
             {
@@ -62256,7 +69984,7 @@
               "gameField": "fTargetCoveragePercentage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "How much of a tile the area must cover before that tile counts as affected.",
               "guard": "SetTargetCoveragePercentage"
             },
             {
@@ -62266,7 +69994,7 @@
               "gameField": "bAddPrimaryTargetAsMultiTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.",
               "guard": "SetAddPrimaryTargetAsMultiTarget"
             },
             {
@@ -62276,7 +70004,7 @@
               "gameField": "bAllowDeadMultiTargetUnits",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Includes already-dead units in the area.",
               "guard": "SetAllowDeadMultiTargetUnits"
             },
             {
@@ -62286,7 +70014,7 @@
               "gameField": "bExcludeSelfAsTargetIfWithinRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Leaves the user out of its own area of effect.",
               "guard": "SetExcludeSelfAsTargetIfWithinRadius"
             },
             {
@@ -62296,7 +70024,7 @@
               "gameField": "AbilityBonusRadii",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Extra radius granted when the unit has a particular ability, merged by RequiredAbility. Lets a perk widen the blast without a separate ability.",
               "modeField": "AbilityBonusRadiiMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -62317,7 +70045,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -62327,7 +70055,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -62337,7 +70065,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -62347,7 +70075,7 @@
               "gameField": "fTargetHeight",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Height of the cylinder in metres.",
               "guard": "SetTargetHeight"
             },
             {
@@ -62357,7 +70085,7 @@
               "gameField": "bUseOnlyGroundTiles",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Restricts the cylinder to ground-level tiles.",
               "guard": "SetUseOnlyGroundTiles"
             },
             {
@@ -62367,7 +70095,7 @@
               "gameField": "bUseWeaponRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the radius from the weapon. TargetRadius is then added on top.",
               "guard": "SetUseWeaponRadius"
             },
             {
@@ -62377,7 +70105,7 @@
               "gameField": "bUseWeaponBlockingCoverFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the weapon's setting for whether cover blocks the area.",
               "guard": "SetUseWeaponBlockingCoverFlag"
             },
             {
@@ -62387,7 +70115,7 @@
               "gameField": "bIgnoreBlockingCover",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Lets the area pass through cover that would otherwise block it.",
               "guard": "SetIgnoreBlockingCover"
             },
             {
@@ -62397,7 +70125,7 @@
               "gameField": "fTargetRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.",
               "guard": "SetTargetRadius"
             },
             {
@@ -62407,7 +70135,7 @@
               "gameField": "fTargetCoveragePercentage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "How much of a tile the area must cover before that tile counts as affected.",
               "guard": "SetTargetCoveragePercentage"
             },
             {
@@ -62417,7 +70145,7 @@
               "gameField": "bAddPrimaryTargetAsMultiTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.",
               "guard": "SetAddPrimaryTargetAsMultiTarget"
             },
             {
@@ -62427,7 +70155,7 @@
               "gameField": "bAllowDeadMultiTargetUnits",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Includes already-dead units in the area.",
               "guard": "SetAllowDeadMultiTargetUnits"
             },
             {
@@ -62437,7 +70165,7 @@
               "gameField": "bExcludeSelfAsTargetIfWithinRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Leaves the user out of its own area of effect.",
               "guard": "SetExcludeSelfAsTargetIfWithinRadius"
             },
             {
@@ -62447,7 +70175,7 @@
               "gameField": "AbilityBonusRadii",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Extra radius granted when the unit has a particular ability, merged by RequiredAbility. Lets a perk widen the blast without a separate ability.",
               "modeField": "AbilityBonusRadiiMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -62468,7 +70196,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -62478,7 +70206,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -62488,7 +70216,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -62498,7 +70226,7 @@
               "gameField": "OnlyAllyOfType",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Restricts targeting to allies of this character type.",
               "guard": "SetOnlyAllyOfType"
             },
             {
@@ -62508,7 +70236,7 @@
               "gameField": "bAcceptFriendlyUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Includes friendly units.",
               "guard": "SetAcceptFriendlyUnits"
             },
             {
@@ -62518,7 +70246,7 @@
               "gameField": "bAcceptEnemyUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Includes hostile units.",
               "guard": "SetAcceptEnemyUnits"
             },
             {
@@ -62528,7 +70256,7 @@
               "gameField": "bOnlyAcceptRoboticUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Restricts targeting to robotic units.",
               "guard": "SetOnlyAcceptRoboticUnits"
             },
             {
@@ -62538,7 +70266,7 @@
               "gameField": "bOnlyAcceptAlienUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Restricts targeting to aliens.",
               "guard": "SetOnlyAcceptAlienUnits"
             },
             {
@@ -62548,7 +70276,7 @@
               "gameField": "bOnlyAcceptAdventUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Restricts targeting to ADVENT units.",
               "guard": "SetOnlyAcceptAdventUnits"
             },
             {
@@ -62558,7 +70286,7 @@
               "gameField": "bRandomlySelectOne",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Picks a single target at random from everything that qualified.",
               "guard": "SetRandomlySelectOne"
             },
             {
@@ -62568,7 +70296,7 @@
               "gameField": "bDontAcceptNeutralUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Leaves civilians and other neutrals out.",
               "guard": "SetDontAcceptNeutralUnits"
             },
             {
@@ -62578,7 +70306,7 @@
               "gameField": "RandomChance",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Percentage chance each qualifying unit is actually included.",
               "guard": "SetRandomChance"
             },
             {
@@ -62588,7 +70316,7 @@
               "gameField": "bUseAbilitySourceAsPrimaryTarget",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Treats the ability's user as the primary target.",
               "guard": "SetUseAbilitySourceAsPrimaryTarget"
             },
             {
@@ -62598,7 +70326,7 @@
               "gameField": "bUseWeaponRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the radius from the weapon. TargetRadius is then added on top.",
               "guard": "SetUseWeaponRadius"
             },
             {
@@ -62608,7 +70336,7 @@
               "gameField": "bUseWeaponBlockingCoverFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the weapon's setting for whether cover blocks the area.",
               "guard": "SetUseWeaponBlockingCoverFlag"
             },
             {
@@ -62618,7 +70346,7 @@
               "gameField": "bIgnoreBlockingCover",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Lets the area pass through cover that would otherwise block it.",
               "guard": "SetIgnoreBlockingCover"
             },
             {
@@ -62628,7 +70356,7 @@
               "gameField": "fTargetRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.",
               "guard": "SetTargetRadius"
             },
             {
@@ -62638,7 +70366,7 @@
               "gameField": "fTargetCoveragePercentage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "How much of a tile the area must cover before that tile counts as affected.",
               "guard": "SetTargetCoveragePercentage"
             },
             {
@@ -62648,7 +70376,7 @@
               "gameField": "bAddPrimaryTargetAsMultiTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.",
               "guard": "SetAddPrimaryTargetAsMultiTarget"
             },
             {
@@ -62658,7 +70386,7 @@
               "gameField": "bAllowDeadMultiTargetUnits",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Includes already-dead units in the area.",
               "guard": "SetAllowDeadMultiTargetUnits"
             },
             {
@@ -62668,7 +70396,7 @@
               "gameField": "bExcludeSelfAsTargetIfWithinRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Leaves the user out of its own area of effect.",
               "guard": "SetExcludeSelfAsTargetIfWithinRadius"
             },
             {
@@ -62678,7 +70406,7 @@
               "gameField": "AbilityBonusRadii",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Extra radius granted when the unit has a particular ability, merged by RequiredAbility. Lets a perk widen the blast without a separate ability.",
               "modeField": "AbilityBonusRadiiMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -62699,7 +70427,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -62709,7 +70437,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -62719,7 +70447,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -62729,7 +70457,7 @@
               "gameField": "ClaymoreEnvironmentalDamage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Environmental damage the claymore blast does to scenery.",
               "guard": "SetClaymoreEnvironmentalDamage"
             },
             {
@@ -62739,7 +70467,7 @@
               "gameField": "bUseWeaponRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the radius from the weapon. TargetRadius is then added on top.",
               "guard": "SetUseWeaponRadius"
             },
             {
@@ -62749,7 +70477,7 @@
               "gameField": "bUseWeaponBlockingCoverFlag",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Takes the weapon's setting for whether cover blocks the area.",
               "guard": "SetUseWeaponBlockingCoverFlag"
             },
             {
@@ -62759,7 +70487,7 @@
               "gameField": "bIgnoreBlockingCover",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Lets the area pass through cover that would otherwise block it.",
               "guard": "SetIgnoreBlockingCover"
             },
             {
@@ -62769,7 +70497,7 @@
               "gameField": "fTargetRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.",
               "guard": "SetTargetRadius"
             },
             {
@@ -62779,7 +70507,7 @@
               "gameField": "fTargetCoveragePercentage",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "How much of a tile the area must cover before that tile counts as affected.",
               "guard": "SetTargetCoveragePercentage"
             },
             {
@@ -62789,7 +70517,7 @@
               "gameField": "bAddPrimaryTargetAsMultiTarget",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.",
               "guard": "SetAddPrimaryTargetAsMultiTarget"
             },
             {
@@ -62799,7 +70527,7 @@
               "gameField": "bAllowDeadMultiTargetUnits",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Includes already-dead units in the area.",
               "guard": "SetAllowDeadMultiTargetUnits"
             },
             {
@@ -62809,7 +70537,7 @@
               "gameField": "bExcludeSelfAsTargetIfWithinRadius",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Leaves the user out of its own area of effect.",
               "guard": "SetExcludeSelfAsTargetIfWithinRadius"
             },
             {
@@ -62819,7 +70547,7 @@
               "gameField": "AbilityBonusRadii",
               "origin": "derived",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor_Radius",
-              "description": "",
+              "description": "Extra radius granted when the unit has a particular ability, merged by RequiredAbility. Lets a perk widen the blast without a separate ability.",
               "modeField": "AbilityBonusRadiiMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -62840,7 +70568,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -62850,7 +70578,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -62860,7 +70588,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -62870,7 +70598,7 @@
               "gameField": "bUseWeaponRadius",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Takes the radius from the weapon. TargetRadius is then added on top.",
               "guard": "SetUseWeaponRadius"
             },
             {
@@ -62880,7 +70608,7 @@
               "gameField": "bUseWeaponBlockingCoverFlag",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Takes the weapon's setting for whether cover blocks the area.",
               "guard": "SetUseWeaponBlockingCoverFlag"
             },
             {
@@ -62890,7 +70618,7 @@
               "gameField": "bIgnoreBlockingCover",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Lets the area pass through cover that would otherwise block it.",
               "guard": "SetIgnoreBlockingCover"
             },
             {
@@ -62900,7 +70628,7 @@
               "gameField": "fTargetRadius",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Radius of the area in metres. Added to the weapon's radius when UseWeaponRadius is set.",
               "guard": "SetTargetRadius"
             },
             {
@@ -62910,7 +70638,7 @@
               "gameField": "fTargetCoveragePercentage",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "How much of a tile the area must cover before that tile counts as affected.",
               "guard": "SetTargetCoveragePercentage"
             },
             {
@@ -62920,7 +70648,7 @@
               "gameField": "bAddPrimaryTargetAsMultiTarget",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Moves the primary target into the multi-target list, so it is treated as part of the area rather than separately.",
               "guard": "SetAddPrimaryTargetAsMultiTarget"
             },
             {
@@ -62930,7 +70658,7 @@
               "gameField": "bAllowDeadMultiTargetUnits",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Includes already-dead units in the area.",
               "guard": "SetAllowDeadMultiTargetUnits"
             },
             {
@@ -62940,7 +70668,7 @@
               "gameField": "bExcludeSelfAsTargetIfWithinRadius",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Leaves the user out of its own area of effect.",
               "guard": "SetExcludeSelfAsTargetIfWithinRadius"
             },
             {
@@ -62950,7 +70678,7 @@
               "gameField": "AbilityBonusRadii",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra radius granted when the unit has a particular ability, merged by RequiredAbility. Lets a perk widen the blast without a separate ability.",
               "modeField": "AbilityBonusRadiiMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -62971,7 +70699,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -62981,7 +70709,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -62991,7 +70719,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -63001,7 +70729,7 @@
               "gameField": "TileWidthExtension",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra tiles of width added to the line.",
               "guard": "SetTileWidthExtension"
             },
             {
@@ -63011,7 +70739,7 @@
               "gameField": "bSightRangeLimited",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Stops the line at the limit of sight.",
               "guard": "SetSightRangeLimited"
             },
             {
@@ -63021,7 +70749,7 @@
               "gameField": "AbilityBonusWidths",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Extra line width granted by a particular ability, merged by RequiredAbility.",
               "modeField": "AbilityBonusWidthsMode",
               "modeEnum": "ENameArrayEditMode"
             }
@@ -63042,7 +70770,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -63052,7 +70780,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -63062,7 +70790,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             },
             {
@@ -63072,7 +70800,7 @@
               "gameField": "NumExtraShots",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Additional shots fired at the same target beyond the first.",
               "guard": "SetNumExtraShots"
             }
           ],
@@ -63092,7 +70820,7 @@
               "gameField": "bAllowSameTarget",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Lets the primary target also be picked up as a multi-target.",
               "guard": "SetAllowSameTarget"
             },
             {
@@ -63102,7 +70830,7 @@
               "gameField": "bUseSourceWeaponLocation",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Measures the area from the shooter's weapon rather than the unit.",
               "guard": "SetUseSourceWeaponLocation"
             },
             {
@@ -63112,7 +70840,7 @@
               "gameField": "NumTargetsRequired",
               "origin": "base",
               "inheritedFrom": "X2AbilityMultiTargetStyleEditor",
-              "description": "",
+              "description": "Minimum targets that must be in the area for the ability to be usable.",
               "guard": "SetNumTargetsRequired"
             }
           ]
@@ -63145,7 +70873,7 @@
               "gameField": "Priority",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Order this trigger runs in relative to others on the same event. Lower runs first.",
               "guard": "SetPriority"
             }
           ],
@@ -63165,7 +70893,7 @@
               "gameField": "ListenerData.EventID",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Event this listener waits for. The handling function can only be assigned in code, so a listener added purely from config never fires - editing an existing one does.",
               "guard": "SetListenerEventID"
             },
             {
@@ -63175,7 +70903,7 @@
               "gameField": "ListenerData.Deferral",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "When the listener runs relative to the event being processed.",
               "guard": "SetListenerDeferral"
             },
             {
@@ -63185,7 +70913,7 @@
               "gameField": "ListenerData.Filter",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Which units the event is accepted from, such as only the source or only the target.",
               "guard": "SetListenerFilter"
             },
             {
@@ -63195,7 +70923,7 @@
               "gameField": "ListenerData.Priority",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Order among listeners for the same event.",
               "guard": "SetListenerPriority"
             }
           ],
@@ -63215,27 +70943,22 @@
               "gameField": "MethodName",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Method on the observer class that the trigger calls.",
               "guard": "SetMethodName"
             },
             {
               "config": "EventObserverClass",
               "type": "string",
               "kind": "scalar",
-              "gameField": null,
+              "gameField": "EventObserverClass",
               "origin": "derived",
               "inheritedFrom": null,
-              "description": "",
+              "description": "Class that observes the event. Loaded by name at runtime.",
               "guard": "SetEventObserverClass"
             }
           ],
           "abstract": false,
-          "notEditable": [
-            {
-              "name": "EventObserverClass",
-              "reason": "class reference"
-            }
-          ]
+          "notEditable": []
         },
         {
           "class": "X2AbilityTriggerEditor_Base",
diff --git a/mkdocs.yml b/mkdocs.yml
index 3ffd55e..7b8e5d4 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -75,6 +75,7 @@ nav:
   - Contributing:
       - contributing/adding-an-editor.md
       - contributing/doc-coverage.md
+      - contributing/coverage-triage.md
 
 extra:
   social: