X2AbilityTemplate: (almost) full content for a better use

AlexCheux · April 3, 2016

Hi,

I am not really good at coding but I wanted to make my own soldier classes for XCom2 so I decided to look at others work... It was really helpfull but I was always losing myself in all the *.uc files to see something here and there. So I decided to make a list of almost everything that could be added to an Ability Template. Since this is done, I was thinking about posting it here.

It might be helpfull for those like me, to have a better vision of what we can do. Hope you will like it.

Enjoy

Copy/Paste in Notepad++ with -> Langage/Java to have a better look.

EDIT: Oh by the way, this is not code. This is what we can use in every classes used by X2AbilityTemplate (sorry if I don't use the right words)

/** ---------------------------------------------------------------------------------------------
COMPOSITION OF X2AbilityTemplate by Thane


With details of all variables and function used
(simulated and protected functions are not there)
enum / struct list used are listed at the end


// ---------------------------------------------------------------------------------------------*/




// ---------------------------------------------------------------------------------------------
/**Templates
//The backbone of all of XCom 2’s gameplay data is the template system. There are data template managers – singletons which construct and hold data templates; data sets – logically grouped data template definitions; and the data templates themselves.
//The game, during initialization, will construct the data template managers. The managers will then find all of the data set classes for the type of data they manage and request for each data set to construct their data templates, which the manager will then store.**
//**(In the case of data templates which require per-difficulty configuration, the data manager will – upon receiving the baseline templates from their data sets – create duplicates of each template for each difficulty, appending the difficulty enum value to the end of the new templates’ object names.)
//During gameplay, various systems will request either a particular data template by name from the appropriate template manager singleton, or will iterate over all templates of a type managed by the template manager.**
//(The manager will return only the specific template or iterate over the set of templates which match the currently selected difficulty.)
//The game will then either access data from the returned template directly, or will construct a new instance of a game state object from the template definition.
//Most typically, when modding, you will want to add new templates. This requires adding a new data set (which extends the appropriate data set base type) and constructing & passing back your new list of templates by overriding the CreateTemplates() function on your data set.*/


/**Abilities
//Every action a unit can take on the battlefield (including moving) is an ability (X2AbilityTemplate; XComGameState_Ability).*/
// ---------------------------------------------------------------------------------------------


//------------Ability Costs, Charges, & Cooldowns------------
//Each use of an ability may have associated costs (X2AbilityCost) that use up action points, charges (X2AbilityCharges) which limit the number of times an ability can be used each battle, or cooldowns (X2AbilityCooldown) which prevents the ability from being used too frequently during a battle.


var array<X2AbilityCost>{        AbilityCosts; 
- X2AbilityCost{
} var bool bFreeCost; //  If TRUE, then ApplyCost should do nothing, but CanAfford will still check the requirements.
- X2AbilityCost_ActionPoints{
var int iNumPoints;
var bool bAddWeaponTypicalCost; // If true, will incur additional action point cost based on weapon's iTypicalActionCost
var bool bConsumeAllPoints;
var bool bMoveCost;
var array<name> AllowedTypes; (default: AllowedTypes(0)="standard"; AllowedTypes(1)="runandgun")


var array<name> DoNotConsumeAllEffects; //  if the ability owner is under any of these effects, the ability will not consume all points
} var array<name> DoNotConsumeAllSoldierAbilities; //  if the ability owner has any of these abilities, the ability will not consume all points
- X2AbilityCost_Ammo{ 
var int iAmmo;
var bool UseLoadedAmmo; //  for grenade abilities on the grenade launcher
} var bool bReturnChargesError; //  use the error code for lack of charges rather than ammo
- X2AbilityCost_Charges{ //  PURPOSE: Deduct charges from an ability when activated.
// Note that many abilities with "charges" rely instead on weapon ammo
// e.g. grenades, medikits
// This is for abilities that are not associated with a weapon, or that have charges separate from ammo. 
var int NumCharges; (default: NumCharges = 1)
var array<name> SharedAbilityCharges; //  names of other abilities which should all have their charges deducted as well. not checked in CanAfford, only modified in ApplyCost.
} var bool bOnlyOnHit; //  only expend charges when the ability hits the target}
- X2AbilityCost_ConsumeItem //Make item disappear, like CombatStims
- X2AbilityCost_HeavyWeaponActionPoints{
default: bConsumeAllPoints = true (in X2AbilityCost_ActionPoints)
} default: DoNotConsumeAllSoldierAbilities(0)="Salvo" (in X2AbilityCost_ActionPoints)
- X2AbilityCost_QuickdrawActionPoints
- X2AbilityCost_ReserveActionPoints{
var int     iNumPoints;
} } var array<name> AllowedTypes;


var X2AbilityCharges{ AbilityCharges; //  Used for configuring the number of charges a unit gets for this ability at tactical start.
- X2AbilityCharges{ //  PURPOSE: Base class for setting charges on an X2AbilityTemplate. 
var int InitialCharges;
} function int GetInitialCharges(XComGameState_Ability Ability, XComGameState_Unit Unit) { return InitialCharges; }
- X2AbilityCharges_CocoonSpawnChryssalid{
} var config int SPAWN_CHARGES;
- X2AbilityCharges_GremlinHeal{ //  PURPOSE: Setup charges for Gremlin Heal ability
var bool bStabilize;
} default:  InitialCharges = 1 (var int InitialCharges in X2AbilityCharges)
- X2AbilityCharges_RevivalProtocol{ //  PURPOSE: Setup charges for Revival Protocol ability
} default:  InitialCharges = 1 (var int InitialCharges in X2AbilityCharges)
- X2AbilityCharges_ScanningProtocol{ //  PURPOSE: Setup charges for Scanning Protocol ability
} default:  InitialCharges = 1 (var int InitialCharges in X2AbilityCharges)
- X2AbilityCharges_StasisLance{
} } var config int BASE_CHARGES;


var X2AbilityCooldown{ AbilityCooldown;
- X2AbilityCooldown{ 
var int iNumTurns;
} var bool bDoNotApplyOnHit;
- X2AbilityCooldown_AidProtocol{
} default: iNumTurns = 2 (X2AbilityCooldown)
- X2AbilityCooldown_Global //  For cooldowns that are shared among all users of this ability for one player.
//  (Set up with CallReinforcements in mind)
- X2AbilityCooldown_LocalAndGlobal{ //  Allows for cooldowns on an individual unit as well as shared among all units of this ability for one player.
} var int NumGlobalTurns;
- X2AbilityCooldown_PerPlayerType{ //  Allows for cooldowns on an individual unit as well as shared among all units of this ability for one player.
// X2AbilityCooldown::iNumTurns is what non-AI controlled units use as the cooldown
} } var int iNumTurnsForAI; // If this unit is controlled by the AI then it uses this value as its cooldown


//------------Ability Hit Calculations------------
//Before damage is dealt, it is necessary to determine if the shot hit the target. Abilities can specify different calculations (X2AbilityToHitCalc) to determine what factors into a hit applying its damage effects.
//Of special note is the hit calculation for most weapon abilities: X2AbilityToHitCalc_StandardAim. Most users’ tactical considerations involving positioning are an effort to improve the hit chance that is calculated by this class: flanking, cover, height advantage, attack range, Aim & Defense stat bonuses, etc.


var X2AbilityToHitCalc AbilityToHitOwnerOnMissCalc; // If !none, a miss on the main target will apply this chance to hit on the target's owner.
var X2AbilityToHitCalc{ AbilityToHitCalc;
- X2AbilityToHitCalc{
var array<ShotModifierInfo> HitModifiers;       // Configured in the ability template to provide always-on modifiers.
function RollForAbilityHit(XComGameState_Ability kAbility, AvailableTarget kTarget, out AbilityResultContext ResultContext);
function bool NoGameStateOnMiss() { return false; }
function AddHitModifier(const int ModValue, const string ModReason, optional EAbilityHitResult ModType=eHit_Success)
} function int GetShotBreakdown(XComGameState_Ability kAbility, AvailableTarget kTarget, optional out ShotBreakdown kBreakdown)
- X2AbilityToHitCalc_DeadEye //Comment: Instead, uses -> Template.AbilityToHitCalc = default.DeadEye (means ALWAYS)
- X2AbilityToHitCalc_Hacking{
} var config int SKULLJACK_HACKING_BONUS;
- X2AbilityToHitCalc_PanicCheck{ //  PURPOSE: Panic hit/miss calculations, Panic Events strength vs Unit Will stat.
} var config array<Name> PanicImmunityAbilities; //  list of abilities which provide panic immunity all of the time
- X2AbilityToHitCalc_RollStat{ 
var ECharStatType StatToRoll; (default = eStat_Offense)
} var int BaseChance; (default = 0) //Comment: set to 10 for Demolition (Grenadier)
- X2AbilityToHitCalc_SeeMovement //  PURPOSE: Defines the abilities that form the concealment / alertness mechanics in X-Com 2. Presently these abilities are only available to the AI.
- X2AbilityToHitCalc_StandardAim{ // Comment: some functions you may want to see here I'm not adding in this file
var bool bIndirectFire; // Indirect fire is stuff like grenades. Hit chance is 100, but crit and dodge and armor mitigation still exists.
var bool bMeleeAttack; // Melee attacks ignore cover and get their own instrinsic hit bonus.
var bool bReactionFire; // Reaction fire suffers specific penalties to the hit roll. Reaction fire also causes the Flanking hit bonus to be ignored.
var bool bAllowCrit; (default =true) // Ability will build crit into the hit table as applicable
var bool bHitsAreCrits; // After the roll is made, eHit_Success will always change into eHit_Crit
var bool bMultiTargetOnly; // Guarantees a success for the ability when there is no primary target.
var bool bOnlyMultiHitWithSuccess; // Multi hit targets will only be hit as long as there is a successful roll (e.g. Sharpshooter's Faceoff ability)
var bool bGuaranteedHit; // Skips all of the normal hit mods but does allow for armor mitigation rolls as normal.
var float FinalMultiplier; (default =1.0f) // Modifier applied to otherwise final aim chance. Will calculate an amount and display the ability as the reason for the modifier.
//  Initial modifiers that are always used by the ability. ModReason will be the ability name.
var int BuiltInHitMod;
} var int BuiltInCritMod; 
- X2AbilityToHitCalc_StandardMelee //Comment: Just set ToHitCalc.bMeleeAttack = true
- X2AbilityToHitCalc_StasisLance{ //Comment: Used by SkullJack and SkullMine (with X2Condition_StasisLanceTarget)
var localized string BaseChance;
var localized string HealthModifier;
var config int BASE_CHANCE; //  base chance before hp adjustments
var config int HP_THRESHOLD; //  hp amount where things are easier while <= this value
var config int CLAMPED_MIN; //  absolute minimum hit chance
} var config int CLAMPED_MAX; //  absolute maximum hit chance
- X2AbilityToHitCalc_StatCheck{
} var int BaseValue; (default =50)
- X2AbilityToHitCalc_StatCheck_UnitVsUnit{
var ECharStatType AttackerStat; (default = eStat_PsiOffense) 
} } var ECharStatType DefenderStat; (default = eStat_Will)


//------------Ability Conditions------------
//Conditions (X2Condition) are used to determine the validity of actions for the shooter and any potential targets. (For example, you cannot shoot anything while you are dead, unconscious, or otherwise impaired; you can never target an enemy that is out of range or not in Line Of Sight).


var array<X2Condition>          AbilityShooterConditions;
var array<X2Condition>          AbilityTargetConditions;
var array<X2Condition>          AbilityMultiTargetConditions;{ //  if conditions are set here, multi targets use these to filter instead of AbilityTargetConditions
//CONDITIONS: A lot of them are not clear to me, some seem to be not used (???). But I decided to put them all here...
- X2Condition{
native function name MeetsCondition(XComGameState_BaseObject kTarget);
native function name MeetsConditionWithSource(XComGameState_BaseObject kTarget, XComGameState_BaseObject kSource);
native function name AbilityMeetsCondition(XComGameState_Ability kAbility, XComGameState_BaseObject kTarget);


// These should ONLY be called from the native functions above.
event name CallMeetsCondition(XComGameState_BaseObject kTarget) { return 'AA_Success'; }
event name CallMeetsConditionWithSource(XComGameState_BaseObject kTarget, XComGameState_BaseObject kSource) { return 'AA_Success'; }
event name CallAbilityMeetsCondition(XComGameState_Ability kAbility, XComGameState_BaseObject kTarget) { return 'AA_Success'; }


} native function name PerformValueCheck(const int Value, const CheckConfig tConfig);
- X2Condition_AbilityProperty{
var array<name> OwnerHasSoldierAbilities;
} var bool TargetMustBeInValidTiles;
- X2Condition_AbilitySourceWeapon{
var bool WantsReload;
var bool CheckAmmo;
var CheckConfig CheckAmmoData;
var bool NotLoadedAmmoInSecondaryWeapon;
var name MatchGrenadeType;
var bool CheckGrenadeFriendlyFire;
var bool CheckAmmoTechLevel;
var name MatchWeaponTemplate; //  requires exact match to weapon's template's DataName
} function AddAmmoCheck(int Value, optional EValueCheck CheckType=eCheck_Exact, optional int ValueMax=0, optional int ValueMin=0)
- X2Condition_BattleState{
var bool bMissionAborted;
var bool bMissionNotAborted;
var bool bCiviliansTargetedByAliens;
} var bool bCiviliansNotTargetedByAliens;
- X2Condition_BerserkerDevastatingPunch
- X2Condition_EverVigilant
- X2Condition_FuseTarget
- X2Condition_GameTime{
var array<CheckConfig> HourChecks;
} function AddHourCheck(int Value, optional EValueCheck CheckType=eCheck_Exact, optional int ValueMax=0, optional int ValueMin=0)
- X2Condition_HackingTarget{
var bool bIntrusionProtocol;
var bool bHaywireProtocol;
} var name RequiredAbilityName;
- X2Condition_HasGrappleLocation
- X2Condition_Interactive{
var UnitInterationType InteractionType;
} var name RequiredAbilityName;
- X2Condition_Lootable{
var bool bRestrictRange;
} var int LootableRange;
- X2Condition_MapProperty{
} var array<string> AllowedBiomes;
- X2Condition_OnGroundTile{
} var name NotAFloorTileTag; (default = "")
- X2Condition_Panic //  PURPOSE: Condition for activating the panic ability in response to a panic event. 
//  Should not be used when applying panic otherwise (e.g. from Insanity).
- X2Condition_PlayerTurns{
} var CheckConfig NumTurnsCheck;
- X2Condition_RevivalProtocol
- X2Condition_StasisLanceTarget //Comment: Used by SkullJack and SkullMine
- X2Condition_StasisTarget //  PURPOSE: Use this in place of a regular UnitProperty condition for Stasis ability.
//           Allows friendlies to be targeted if the source unit has Stasis Shield.
- X2Condition_Stealth //  PURPOSE: Special condition for activating the Ranger Stealth ability.
- X2Condition_UnblockedNeighborTile //Comment: see Viper's Tongue Pull for ex.
- X2Condition_UnitActionPoints{
//  NOTE: Unlike the UnitValue and UnitStatCheck conditions, which fail on any value failing, ActionPonits will succeed if any value succeeds. Frequently you'd want to group multiple action point types, so that the check will pass if the unit has any one of: standard, move, reflex. Abilities generally don't care which type you have, just that you have one of them. If you really need to validate multiple different types, just use multiple conditions.
} function AddActionPointCheck(int Value, optional name Type=class'X2CharacterTemplateManager'.default.StandardActionPoint, optional bool bReserve=false, optional EValueCheck CheckType=eCheck_Exact, optional int ValueMax=0, optional int ValueMin=0)
- X2Condition_UnitAlertStatus{ //Presently these abilities are only available to the AI.
var int RequiredAlertStatusMaximum; // default -1, means ignored.
} var int RequiredAlertStatusMinimum; // default -1, means ignored.
- X2Condition_UnitEffects{
var array<EffectReason> ExcludeEffects; //Units affected by any effect will be rejected with the given reason
var array<EffectReason> RequireEffects; //Condition will fail unless every effect in this list is on the unit
function AddExcludeEffect(name EffectName, name Reason)
} function AddRequireEffect(name EffectName, name Reason)
- X2Condition_UnitEffectsWithAbilitySource //Comment:  seems to be used to prevent an ability to happen twice on the same target (ex. KillZone, BladeStorm...)
- X2Condition_UnitEffectsWithAbilityTarget //Comment: no idea...
- X2Condition_UnitImmunities{ //Comment: Psi Abilities relates
var array<name> ExcludeDamageTypes; //Units immune to these damage types will be excluded.
var bool bOnlyOnCharacterTemplate;
} function AddExcludeDamageType(name DamageType)
- X2Condition_UnitInEvacZone //  PURPOSE: Condition for determining if a unit is currently in the evac zone.
- X2Condition_UnitInteractions{
} var UnitInterationType InteractionType;
- X2Condition_UnitInventory{
var EInventorySlot RelevantSlot;
var name ExcludeWeaponCategory; //Comment: used to exclude 'ThrowGrenade' from Grenadiers if they have a GrenadeLauncher equipped
} var name RequireWeaponCategory; //Comment: Seems to be not used yet
- X2Condition_UnitProperty{
/** Simple properties on the unit */
var bool ExcludeAlive;
var bool ExcludeDead; (default = true)
var bool ExcludeRobotic;
var bool ExcludeOrganic;
var bool ExcludeCivilian; // excludes based on character template property, not team
var bool ExcludeNonCivilian; // excludes based on character template property, not team
var bool ExcludeCosmetic; (default = true) // if a unit is flagged as cosmetic, ignore it
var bool ExcludeImpaired;
var bool ExcludePanicked;
var bool ExcludeInStasis; (default = true)
var bool ExcludeTurret;
var bool IsAdvent;
var bool ExcludeNoCover; //  checks if the target has cover or not
var bool ExcludeNoCoverToSource; //  checks the cover between the target and source
var bool ExcludeFullHealth; //  ignore target if it is at full HP, unless it IsBurning, IsAcidBurning, or IsPoisoned
var bool IsBleedingOut;
var bool IsUnspotted;
var bool CanBeCarried;
var bool IsOutdoors;
var bool IsConcealed;
var bool ExcludeConcealed; //  normally visibility rules take care of this - this is only for MeetsCondition, not MeetsConditionWithSource
var bool IsImpaired;
var bool HasClearanceToMaxZ;
var bool ExcludeAlien;
var bool ExcludeStunned;
var bool IsPlayerControlled;
var bool ExcludeUnrevealedAI;
var bool IncludeWeakAgainstTechLikeRobot;
var bool ImpairedIgnoresStuns;


var int MinRank; (default = 0) //Comment: What is that?
var int MaxRank; (default = 100000) //Comment: What is that?


var array<name> ExcludeSoldierClasses; // condition will fail if the unit has a soldier class in this list. non-soldiers will always pass.
var array<name> RequireSoldierClasses; // condition will fail if the unit's soldier class does not appear in this list (if it is not empty). non-soldiers will always fail.


/** Properties to match against the source unit */
var bool ExcludeHostileToSource; //  disallow units that are hostile to the source
var bool ExcludeFriendlyToSource; (default = true) //  disallow units that are friendly to the source
var bool TreatMindControlledSquadmateAsHostile; //  if a squadmate is mind controlled (i.e. it used to be your enemy), normally they are considered friendly. consider them hostile instead.
var bool ExcludeSquadmates; //  target unit's team must be different than the sources (e.g. civilians and aliens would meet this for xcom)
var bool RequireSquadmates; //  target unit and source unit teams must be the same (e.g. xcom and xcom only, no civilians or aliens allowed)
var bool RequireWithinRange; //  requires that the target be within some range to the source
var float WithinRange; //  allowed VSize (in unreal units) between source and target positions
var bool RequireWithinMinRange; //  requires that the target be within a minimum range from the source
var float WithinMinRange; //  allowed VSize (in unreal units) between source and target positions
var bool BeingCarriedBySource;


var bool FailOnNonUnits; (default =false) //Users must explicitly flag whether their condition can return 'AA_NotAUnit')
} //  defines whether this condition should return a failure for non units ('AA_NotAUnit') or just pass through (success)
- X2Condition_UnitStatCheck{
var array<CheckStat> m_aCheckStats;
} function AddCheckStat(ECharStatType StatType, int Value, optional EValueCheck CheckType=eCheck_Exact, optional int ValueMax=0, optional int ValueMin=0, optional bool bCheckAsPercent=false)
- X2Condition_UnitValue{
var array<CheckValue> m_aCheckValues;
function AddCheckValue(name UnitValue, int Value, optional EValueCheck CheckType=eCheck_Exact, optional int ValueMax=0, optional int ValueMin=0, optional name OptionalOverrideFalureCode='')
} //Comment: for ex. this function is used to check if a unit is not yet a psi-zombie to apply the ability
- X2Condition_ValidUnburrowTile
- X2Condition_Visibility{
var bool bNoEnemyViewers; //Condition will fail if the target can be seen by any enemies


//Require a specific cover type
var bool bRequireMatchCoverType;
// Require that a specific cover type is not being used
var bool bRequireNotMatchCoverType;
var ECoverType TargetCover; //Cover type to match


//Require that the shooter can shoot from their 'default' tile ( no peeking )
var bool bCannotPeek; //Requires bVisibleFromdefault to be FALSE


//Require a specific visibility settings
var bool bRequireLOS;
var bool bRequireBasicVisibility; //LOS + in range
var bool bRequireGameplayVisible; //LOS + in range + meets situational conditions in interface method UpdateGameplayVisibility
var bool bAllowSquadsight; //LOS + any squadmate can see the target, if unit has Squadsight (overrides bRequireGameplayVisible)
var bool bActAsSquadsight; //LOS + any squadmate can see the target, regardless of if the unit has Squadsight (overrides bRequireGameplayVisible)
var bool bVisibleToAnyAlly; //any squadmate can see the target, regardless of if the unit has Squadsight (overrides bRequireGameplayVisible)
var bool bDisablePeeksOnMovement; (default = false) //For most abilities, this is allowed. Exceptions are, for example, over watch.)
//If TRUE, peeks cannot be used if bTargetMoved is true in the vis info
var bool bExcludeGameplayVisible; //condition will FAIL if there is GameplayVisibility FROM the target TO the source


//GameplayVisibleTags are contextual flags that can be added to the visibility info during UpdateGameplayVisibility. They give context to the 
//state of bGameplayVisible, ie. 'stealthed', 'concealed', 'kismetseqact', etc.
var init array<name> RequireGameplayVisibleTags; 


} } default: RequiredOnlyForActivation=true //Wich is the var private bool in X2Condition


//------------Ability Effects------------
//Once a hit has been determined, ability effects (X2Effect) actually apply the results of the hit to the target(s). These effects may apply straight up damage (X2Effect_ApplyWeaponDamage) or they may inflict persistent (X2Effect_Persistent) stat changes, physical dots (like burning, poison, or acid), or mental status effects (like panic, berserk, or mind control). A good number of these common effects are defined in a helper class (X2StatusEffects). 


var protectedwrite array<X2Effect> AbilityTargetEffects; //  effects which apply to the main target only
var protectedwrite array<X2Effect> AbilityMultiTargetEffects; //  effects which apply to the multi targets only
var protectedwrite array<X2Effect> AbilityShooterEffects;{ //  effects which always apply to the shooter, regardless of targets
//------Too many X2Effect... I listed only the ones I think to be really important, and became lazy at the end...---------
- X2Effect{
var array<X2Condition>  TargetConditions;
var bool bApplyOnHit;
var bool bApplyOnMiss;
var bool bApplyToWorldOnHit;
var bool bApplyToWorldOnMiss;
var bool bUseSourcePlayerState; // If true, the source player's reference will be saved in PlayerStateObjectRef when the effect is applied
var int ApplyChance;
var delegate<ApplyChanceCheck> ApplyChanceFn;
var int MinStatContestResult; // The AbilityResultContext (in the EffectAppliedData) StatContestResult must be >= this number for the effect to apply.
var int MaxStatContestResult; // The AbilityResultContext (in the EffectAppliedData) StatContestResult must be <= this number for the effect to apply. Ignored if value < Min.
var array<name> DamageTypes; // Units immune to any damage type listed here will resist the effect. For persistent effects, cleansing effects might look for a damage type to know to remove it.
var bool bIsImpairing; // If this effect impairs the unit, then an event must be sent out
var bool bIsImpairingMomentarily; // Sends event but does not continue to report unit as impaired
var bool bBringRemoveVisualizationForward; // If this effect's visualization needs to be moved forward, the context's whole visualization is moved
var bool bShowImmunity; //  Default visualization will show a flyover to indicate a unit's immunity to this effect when applicable (effect application was AA_UnitIsImmune)
var bool bShowImmunityAnyFailure; //  Default visualization will show a flyover to indicate a unit's immunity if the effect fails for any reason (effect application was not AA_Success)
var float DelayVisualizationSec;
} var bool bAppliesDamage; // if this effect should be considered as damage to control stats and some generic ability damage event generation
- X2Effect_ApplyAcidToWorld{
var config string AcidParticleSystemFill_Name_1pc;
var config string AcidParticleSystemFill_Name_2pc;
var config string AcidParticleSystemFill_Name_3pc_Long;
var config string AcidParticleSystemFill_Name_3pc_Corner;
var config string AcidParticleSystemFill_Name_4pc_Long;
var config string AcidParticleSystemFill_Name_4pc_Square;
var config string AcidParticleSystemFill_Name_4pc_L;
var config string AcidParticleSystemFill_Name_4pc_Reverse_L;
var config string AcidParticleSystemFill_Name_4pc_Middle;
var config string AcidParticleSystemFill_Name_4pc_S;
var config string AcidParticleSystemFill_Name_4pc_Reverse_S;
function DetermineBlocks( array<TileIsland> TileIslands, out array<TilePosPair> OutTiles, out array<TileParticleInfo> OutParticleInfos )
default: DamageTypes.Add("Acid") (in X2Effect)
} default: bCenterTile=false (in X2Effect_World)
- X2Effect_ApplyDirectionalWorldDamage{
var int EnvironmentalDamageAmount;
var name DamageTypeTemplateName;
var int PlusNumZTiles; (default = 0)
var bool bUseWeaponEnvironmentalDamage;
var bool bUseWeaponDamageType;
var bool bHitSourceTile;
var bool bHitTargetTile;
var bool  bHitAdjacentDestructibles;
} default: bAppliesDamage=true (in X2Effect)
- X2Effect_ApplyFireToWorld{
var config string FireParticleSystemFill_Name;
var config int MAX_INTENSITY_2_TILES;
var config int LimitFireSpreadTiles; //Once there are this many tiles on fire in the world, the spread of fire will be limited to one new fire per turn
var config float FillIntensityLERPTimeSecs;
var float FireChance_Level1; (default = 0.25f)
var float FireChance_Level2; (default = 0.5f)
var float FireChance_Level3; (default = 0.25f)
var bool bUseFireChanceLevel; (default = false)
var bool bDamageFragileOnly; (default = false)
var bool bCheckForLOSFromTargetLocation; (default = true) //If set to true, only tiles that are visible from the target location will be set on fire
default: bCenterTile = false; (in X2Effect_World)
} default: DamageTypes.Add("Fire"); (in X2Effect)
- X2Effect_ApplyMedikitHeal{
var int PerUseHP; //  amount of HP to heal for any application of the effect
var localized string HealedMessage;
var name IncreasedHealProject; //  HQ project that will use IncreasedPerUseHP
} var int IncreasedPerUseHP; //  used instead of PerUseHP if the above project is known
- X2Effect_ApplyPoisonToWorld{
var config string PoisonParticleSystemFill_Name;
var config int Duration;
default: bCenterTile = false; (in X2Effect_World)
} default: DamageTypes.Add("Poison"); (in X2Effect)
- X2Effect_ApplySmokeGrenadeToWorld{
var config string SmokeParticleSystemFill_Name;
var config int Duration;
} default: bCenterTile = true; (in X2Effect_World)
- X2Effect_ApplySmokeToWorld{
} var config string SmokeParticleSystemFill_Name;
- X2Effect_ApplyWeaponDamage{
var bool bExplosiveDamage;
var bool bIgnoreBaseDamage; //Comment: to ignore damage based on weapon and use damage corrsponding to a Tag instead
var name DamageTag;
var bool bAlwaysKillsCivilians;
var bool bApplyWorldEffectsForEachTargetLocation; (default = false)
var bool bAllowFreeKill; (default = true)
var bool bAllowWeaponUpgrade;
var bool bBypassShields;
// These values are extra amount an ability may add or apply directly
var WeaponDamageValue EffectDamageValue;
var int EnvironmentalDamageAmount;
var config float GRAZE_DMG_MULT;
function WeaponDamageValue GetBonusEffectDamageValue(XComGameState_Ability AbilityState, XComGameState_Item SourceWeapon, StateObjectReference TargetRef) { return EffectDamageValue; }
} default: bAppliesDamage=true (in X2Effect)
- X2Effect_APRounds{
var int Pierce;
var int CritChance;
var int CritDamage;
} default: DuplicateResponse = eDupe_Ignore (X2Effect_Persistent)
- X2Effect_AuraSource
- X2Effect_BiggestBooms{
var config int CRIT_CHANCE_BONUS;
var config int CRIT_DAMAGE_BONUS;
} function bool AllowCritOverride() { return true; }
- X2Effect_BlastPadding{
var float ExplosiveDamageReduction;
} var config int ARMOR_CHANCE, ARMOR_MITIGATION;
- X2Effect_BleedingOut
- X2Effect_BonusArmor{
function int GetArmorChance(XComGameState_Effect EffectState, XComGameState_Unit UnitState) { return 0; }
function int GetArmorMitigation(XComGameState_Effect EffectState, XComGameState_Unit UnitState) { return 0; }
} function string GetArmorName(XComGameState_Effect EffectState, XComGameState_Unit UnitState) { return FriendlyName; }
- X2Effect_BonusWeaponDamage{//  PURPOSE: Add a flat damage amount if the ability's source weapon matches the source weapon of this effect. Since weapons can define their own damage, this is really for when the damage is temporary, or is coming from a specific soldier ability and therefore not everyone with the same weapon gets the bonus.
var int BonusDmg;
} function int GetAttackingDamageModifier(XComGameState_Effect EffectState, XComGameState_Unit Attacker, Damageable TargetDamageable, XComGameState_Ability AbilityState, const out EffectAppliedData AppliedData, const int CurrentDamage) 
- X2Effect_BreakUnitConcealment
- X2Effect_Burning{ //  PURPOSE: Handles unique burning effect rules - always has a damage effect to apply, and being hit with a 2nd burning effect causes the greater of two damages to apply, while refreshing the duration no matter what.
default: DamageTypes(0)="Fire"; (in X2Effect)
default: DuplicateResponse=eDupe_Refresh; (in X2Effect_Persistent)
} default: ApplyOnTick.Add(BurnDamage); (in X2Effect_Persistent)
- X2Effect_Confused
- X2Effect_CoveringFire{
var name AbilityToActivate; //  ability to activate when the covering fire check is matched
var name GrantActionPoint; //  action point to give the shooter when covering fire check is matched
var int MaxPointsPerTurn;  //  max times per turn the action point can be granted
var bool bDirectAttackOnly; //  covering fire check can only match when the target of this effect is directly attacked
var bool bPreEmptiveFire; (default = true) //  if true, the reaction fire will happen prior to the attacker's shot; otherwise it will happen after
} var bool bOnlyDuringEnemyTurn; //  only activate the ability during the enemy turn (e.g. prevent return fire during the sharpshooter's own turn)
- X2Effect_DamageImmunity{
var array<name> ImmuneTypes;
var bool ImmueTypesAreInclusive; (default = true)
var int RemoveAfterAttackCount;
function bool ProvidesDamageImmunity(XComGameState_Effect EffectState, name DamageType)
} function RegisterForEvents(XComGameState_Effect EffectGameState)
- X2Effect_DelayedAbilityActivation{
var name TriggerEventName;      // Used to identify the event that this effect will trigger
} default:  EffectRemovedFn = TriggerAssociatedEvent (in X2Effect_Persistent)
- X2Effect_DisableWeapon{
var localized string DisabledWeapon;
} var localized string FailedDisable;
- X2Effect_EnableGlobalAbility{
} var name GlobalAbility;
- X2Effect_EnergyShield{
default: EffectName="EnergyShieldEffect"; (in X2Effect_Persistent)
} default: DuplicateResponse=eDupe_Refresh; (in X2Effect_Persistent)
- X2Effect_Fortress{
var config array<name> DamageImmunities;
default:  EffectName="PsiFortress"; (in X2Effect_Persistent)
} default: DuplicateResponse=eDupe_Ignore; (in X2Effect_Persistent)
- X2Effect_GrantActionPoints{
var int NumActionPoints;
} var name PointType;
- X2Effect_ModifyStats //  PURPOSE: Base class for effects that want to modify unit stats. Handles applying and unapplying the stat mods. Child classes should update the XComGameState_Effect's StatChanges array inside of their own OnEffectAdded, before calling the one here. See X2Effect_PersistentStatChange for an example.
- X2Effect_Persistent{
var array<X2EffectTrigger> TickTriggers;


var int iNumTurns;
var int iInitialShedChance;
var int iPerTurnShedChance;
var bool bInfiniteDuration;
var bool bTickWhenApplied;
var bool bRemoveWhenSourceDies;
var bool bRemoveWhenTargetDies;
var bool bRemoveWhenSourceDamaged;
var bool bRemoveWhenTargetConcealmentBroken;
var bool bIgnorePlayerCheckOnTick;
var bool bUniqueTarget; // for a given source, this effect may only apply to one target. any pre-existing effect on another target is removed in HandleApplyEffect
var bool bStackOnRefresh; // increment the stack counter on the effect state when this effect is refreshed
var bool bDupeForSameSourceOnly; // when adding the effect to a target, any similar effects coming from a different source are ignored when checking for a pre-existing effect
var EDuplicateEffect DuplicateResponse; (default = eDupe_Allow)
var array<X2Effect> ApplyOnTick; // These non-persistent effects are applied with the same target parameters every tick
var GameRuleStateChange WatchRule; // the rule determining when this effect needs to tick
var name CustomIdleOverrideAnim; // tells the Idle state machine that a persistent effect is taking over animation
var int EffectRank; (default = 0) // This rank currently is used by auras. The value of the rank to allow different unit templates pply effects with the same aura type.
var name EffectName; // Used to identify the effect for purposes of stacking with other effects.
var EPerkBuffCategory BuffCategory;
var Name AbilitySourceName; // Used to color passive buffs in the HUD
var bool bDisplayInUI; (default = false) // Effect will only appear in German mode if this is true
var string FriendlyName; // Used in German mode UI
var string FriendlyDescription; // Used in German mode UI
var string IconImage;
//  UI display info for effect SOURCE - usually only applicable for certain abilities, such as Mind Control, where you need to distinguish the source and the target
var EPerkBuffCategory SourceBuffCategory;
var bool bSourceDisplayInUI;
var string SourceFriendlyName;
var string SourceFriendlyDescription;
var string SourceIconLabel;
var string StatusIcon;
var int EffectHierarchyValue; (default = -1)// This is used to signify which effects have precedence over other effects. This controls which effect might control the animation if multiple persistent effects are present. A value of -1 is default and means it is not in the hierarchy. Blocks of 100 to allow for changes.
var name ChanceEventTriggerName; // Event to trigger if we pass the trigger shed chance percent check


var string VFXTemplateName; // Name of a particle system to play on the unit while this persistent effect is active
var name VFXSocket; // The name of a socket to which the particle system component should be attached. (optional)
var name VFXSocketsArrayName; // Name associated with an array of sockets the particle system will attach to. (optional)
var float VisionArcDegreesOverride; (default = 360.0f) // This will limit the sight arc of the character.  If 2 effects have this it chooses the smaller arc.


var delegate<AddEffectVisualization> VisualizationFn;
var delegate<AddEffectVisualization> CleansedVisualizationFn;
var delegate<AddEffectVisualization> EffectTickedVisualizationFn;
var delegate<AddEffectVisualization> EffectRemovedVisualizationFn;
var delegate<AddEffectVisualization> EffectRemovedSourceVisualizationFn;
var delegate<AddEffectVisualization_Death> DeathVisualizationFn;
var delegate<EffectRemoved> EffectRemovedFn;
var delegate<EffectAdded> EffectAddedFn;
var delegate<EffectTicked> EffectTickedFn;


simulated function BuildPersistentEffect(int _iNumTurns, optional bool _bInfiniteDuration=false, optional bool _bRemoveWhenSourceDies=true, optional bool _bIgnorePlayerCheckOnTick=false, optional GameRuleStateChange _WatchRule=eGameRule_TacticalGameStart )
simulated function SetDisplayInfo(EPerkBuffCategory BuffCat, string strName, string strDesc, string strIconLabel, optional bool DisplayInUI=true, optional string strStatusIcon = "", optional Name opAbilitySource = 'eAbilitySource_Standard')
simulated function SetSourceDisplayInfo(EPerkBuffCategory BuffCat, string strName, string strDesc, string strIconLabel, optional bool DisplayInUI=true, optional Name opAbilitySource = 'eAbilitySource_Standard')
simulated function bool FullTurnComplete(XComGameState_Effect kEffect)
simulated function bool OnEffectTicked(const out EffectAppliedData ApplyEffectParameters, XComGameState_Effect kNewEffectState, XComGameState NewGameState, bool FirstApplication)
simulated function OnEffectRemoved(const out EffectAppliedData ApplyEffectParameters, XComGameState NewGameState, bool bCleansed, XComGameState_Effect RemovedEffectState)
simulated protected function OnEffectAdded(const out EffectAppliedData ApplyEffectParameters, XComGameState_BaseObject kNewTargetState, XComGameState NewGameState, XComGameState_Effect NewEffectState)


function bool IsThisEffectBetterThanExistingEffect(const out XComGameState_Effect ExistingEffect)
function int GetStartingNumTurns(const out EffectAppliedData ApplyEffectParameters)


function UnitEndedTacticalPlay(XComGameState_Effect EffectState, XComGameState_Unit UnitState);
function bool IsEffectCurrentlyRelevant(XComGameState_Effect EffectGameState, XComGameState_Unit TargetUnit) { return true; }
function RegisterForEvents(XComGameState_Effect EffectGameState);
function bool AllowCritOverride() { return false; }
function bool ShotsCannotGraze() { return false; }
function bool ChangeHitResultForAttacker(XComGameState_Unit Attacker, XComGameState_Unit TargetUnit, XComGameState_Ability AbilityState, const EAbilityHitResult CurrentResult, out EAbilityHitResult NewHitResult) { return false; }
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);
function bool UniqueToHitModifiers() { return false; }
function GetToHitAsTargetModifiers(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);
function bool UniqueToHitAsTargetModifiers() { return false; }
function int GetAttackingDamageModifier(XComGameState_Effect EffectState, XComGameState_Unit Attacker, Damageable TargetDamageable, XComGameState_Ability AbilityState, const out EffectAppliedData AppliedData, const int CurrentDamage) { return 0; }
function int GetDefendingDamageModifier(XComGameState_Effect EffectState, XComGameState_Unit Attacker, Damageable TargetDamageable, XComGameState_Ability AbilityState, const out EffectAppliedData AppliedData, const int CurrentDamage, X2Effect_ApplyWeaponDamage WeaponDamageEffect) { return 0; }
function int GetExtraArmorPiercing(XComGameState_Effect EffectState, XComGameState_Unit Attacker, Damageable TargetDamageable, XComGameState_Ability AbilityState, const out EffectAppliedData AppliedData) { return 0; }
function int GetExtraShredValue(XComGameState_Effect EffectState, XComGameState_Unit Attacker, Damageable TargetDamageable, XComGameState_Ability AbilityState, const out EffectAppliedData AppliedData) { return 0; }
function ModifyTurnStartActionPoints(XComGameState_Unit UnitState, out array<name> ActionPoints, XComGameState_Effect EffectState);
function bool AllowReactionFireCrit(XComGameState_Unit UnitState, XComGameState_Unit TargetState) { return false; }
function ModifyReactionFireSuccess(XComGameState_Unit UnitState, XComGameState_Unit TargetState, out int Modifier);
function bool ProvidesDamageImmunity(XComGameState_Effect EffectState, name DamageType) { return false; }
function ModifyGameplayVisibilityForTarget(out GameRulesCache_VisibilityInfo InOutVisibilityInfo, XComGameState_Unit SourceUnit, XComGameState_Unit TargetUnit);
function bool PostAbilityCostPaid(XComGameState_Effect EffectState, XComGameStateContext_Ability AbilityContext, XComGameState_Ability kAbility, XComGameState_Unit SourceUnit, XComGameState_Item AffectWeapon, XComGameState NewGameState, const array<name> PreCostActionPoints, const array<name> PreCostReservePoints) { return false; }
function GetStatCheckModToSuccessCheck(XComGameState_Effect EffectState, XComGameState_Unit UnitState, XComGameState_Ability AbilityState, out int Successes);
function bool RetainIndividualConcealment(XComGameState_Effect EffectState, XComGameState_Unit UnitState) { return false; }     //  return true to keep individual concealment when squad concealment is broken
function bool DoesEffectAllowUnitToBleedOut(XComGameState_Unit UnitState) { return true; }
function bool DoesEffectAllowUnitToBeLooted(XComGameState NewGameState, XComGameState_Unit UnitState) { return true; }
function bool CanAbilityHitUnit(name AbilityName) { return true; }
function bool PreDeathCheck(XComGameState NewGameState, XComGameState_Unit UnitState, XComGameState_Effect EffectState) { return false; }
function bool PreBleedoutCheck(XComGameState NewGameState, XComGameState_Unit UnitState, XComGameState_Effect EffectState) { return false; }


//  Modify the value that is displayed by XComGameState_Unit:GetUISummary_UnitStats (e.g. tooltip of stats in lower left)
function ModifyUISummaryUnitStats(XComGameState_Effect EffectState, XComGameState_Unit UnitState, const ECharStatType Stat, out int StatValue);


// By default this returns eGameplayBlocking_DoesNotModify because most effects don't change blocking
function EGameplayBlocking ModifyGameplayPathBlockingForTarget(const XComGameState_Unit UnitState, const XComGameState_Unit TargetUnit) { return eGameplayBlocking_DoesNotModify; }


// By default this returns eGameplayBlocking_DoesNotModify because most effects don't change blocking
function EGameplayBlocking ModifyGameplayDestinationBlockingForTarget(const XComGameState_Unit UnitState, const XComGameState_Unit TargetUnit) { return eGameplayBlocking_DoesNotModify; }




//  Register an effect in the config array EffectUpdatesOnMove on AbilityTemplateManager in order to receive these callbacks
function OnUnitChangedTile(const out TTile NewTileLocation, XComGameState_Effect EffectState, XComGameState_Unit TargetUnit);


// This is used to test if the effect being visualized is the first visualization of that particular effect on a particular unit in the current event chain.  This is used to prevent repeated showings of effect related flyovers.
} function bool IsFirstMatchingEffectInEventChain(XComGameState VisualizeGameState)
- X2Effect_PersistentSquadViewer //Comment: Used by Battle scanner and scanning protocol
- X2Effect_PersistentStatChange{
} var array<StatChange> m_aStatChanges;
- X2Effect_RangerStealth  (default: EffectName = "RangerStealth") //  PURPOSE: Main effect for the Ranger Stealth ability, which handles Concealment.
- X2Effect_Reaper{
var config int DMG_REDUCTION;
var name ReaperActivatedName; (default = "ReaperActivated")
var name ReaperKillName; (default = "ReaperKillCount")
} default: DuplicateResponse = eDupe_Ignore
- X2Effect_Regeneration{
var int HealAmount;
var int MaxHealAmount;
var name HealthRegeneratedName;
var name EventToTriggerOnHeal;
default: EffectName="Regeneration"
} default: EffectTickedFn=RegenerationTicked
- X2Effect_RemoveEffects{
var array<name> EffectNamesToRemove;
var bool bCleanse; (default = true) //  Indicates the effect was removed "safely" for gameplay purposes so any bad "wearing off" effects should not trigger
//  e.g. Bleeding Out normally kills the soldier it is removed from, but if cleansed, it won't.
} var bool bCheckSource; //  Match the source of each effect to the target of this one, rather than the target.
- X2Effect_RemoveEffectsByDamageType{
var array<name> DamageTypesToRemove;
} default: ApplyChanceFn=DamageTypesRelevant
- X2Effect_ReserveActionPoints{ //Comment: Used by all kind of overwatch abilities (KillZone, Suppression...)
var name ReserveType;       //  type of action point to reserve
} var int NumPoints; (default = 1) //  number of points to reserve
- X2Effect_ReserveOverwatchPoints //  PURPOSE: Specifically for Overwatch; allows Pistols to use their own action points,  making it easier to distinguish from the Sniper Rifle.
- X2Effect_RestoreActionPoints //  PURPOSE: Bring a unit's standard action points back to the normal amount.
//----------From this point I becam lazy and did not fill all of the informations I usued to copy...--------------
- X2Effect_Serial
- X2Effect_Shredder
- X2Effect_StunRecover
- X2Effect_Suppression{
var config int SoldierTargetAimPenalty;     //  inside GetToHitModifiers, this value is used if the Attacker is not on eTeam_XCom (because a soldier hit this unit with suppression)
var config int AlienTargetAimPenalty;       //  as above, but only for eTeam_XCom (because an alien hit this xcom unit with suppression)
} var config int MultiplayerTargetAimPenalty; //  the value used in MP games
- X2Effect_Sustain
- X2Effect_TalonRounds
- X2Effect_ToHitModifier{
var array<EffectHitModifier> Modifiers;
var array<X2Condition> ToHitConditions;
var bool bApplyAsTarget; (default = false)
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)
} function GetToHitAsTargetModifiers(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)
- X2Effect_TriggerEvent
- X2Effect_TurnStartActionPoints{
var name ActionPointType;
var int NumActionPoints;
} default: EffectAddedFn=EffectAddedCallback
- X2Effect_VolatileMix{
var int BonusDamage;
} DuplicateResponse = eDupe_Ignore
- X2Effect_World //  Base class for effects that are applied to the world, and not to units. These require additional handling. This indirection allows the world data to generically apply effects to objects entering tiles.
- X2EffectTrigger //This class is empty...
- X2EffectTrigger_Event{
var class EventObserverClass;
var name MethodName;
} } var GameRuleStateChange WatchRule;


//------------Ability Targeting------------
//Abilities can have different selection mechanisms for targeting enemies (X2AbilityTargetStyle). For standard shots, this is just choosing a single enemy unit, but abilities like throwing a grenade requires selecting a tile to throw the grenade at.


var X2AbilityTargetStyle{ AbilityTargetStyle;
- X2AbilityTargetStyle //Comment: Functions and comments here
- X2AbilityTarget_Cursor{
var bool bRestrictToWeaponRange;
var int IncreaseWeaponRange;
var bool bRestrictToSquadsightRange;
} var int FixedAbilityRange; (default = -1)
- X2AbilityTarget_MovingMelee{
} bAllowDestructibleObjects=true
- X2AbilityTarget_Path
- X2AbilityTarget_Self
} - X2AbilityTarget_Single{
var bool OnlyIncludeTargetsInsideWeaponRange;
var bool bAllowInteractiveObjects;
var bool bAllowDestructibleObjects;
var bool bIncludeSelf;
} var bool bShowAOE;
var X2AbilityMultiTargetStyle{ AbilityMultiTargetStyle;
- X2AbilityMultiTargetStyle{ //Comment: Functions and comments here
var bool bAllowSameTarget;
var bool bUseSourceWeaponLocation;
} var int NumTargetsRequired;
- X2AbilityMultiTarget_AllAllies{
} default: bAcceptFriendlyUnits = true
- X2AbilityMultiTarget_AllUnits{
var name OnlyAllyOfType;
var bool bAcceptFriendlyUnits;
var bool bAcceptEnemyUnits;
var bool bOnlyAcceptRoboticUnits;
var bool bOnlyAcceptAlienUnits;
var bool bOnlyAcceptAdventUnits;
var bool bRandomlySelectOne;
var bool bDontAcceptNeutralUnits; (default = true)
} var int RandomChance;
- X2AbilityMultiTarget_BlazingPinions
- X2AbilityMultiTarget_BurstFire{
var int NumExtraShots;
} default: bAllowSameTarget=true
- X2AbilityMultiTarget_Cone{
var float ConeEndDiameter;
var float ConeLength;
} var bool bUseWeaponRangeForLength;
- X2AbilityMultiTarget_Cylinder{
var float fTargetHeight; //  Meters! (for now)
var bool bUseOnlyGroundTiles;
} default: bUseOnlyGroundTiles=false
- X2AbilityMultiTarget_Line{
var int TileWidthExtension; // Extend the width of the line by this many tiles.
} var bool bSightRangeLimited; (default = true)
- X2AbilityMultiTarget_Loot
- X2AbilityMultiTarget_Radius{
var bool bUseWeaponRadius;
var bool bIgnoreBlockingCover;
var float fTargetRadius; //  Meters! (for now) If bUseWeaponRadius is true, this value is added on.
var float fTargetCoveragePercentage;
var bool bAddPrimaryTargetAsMultiTarget; //  GetMultiTargetOptions & GetMultiTargetsForLocation will remove the primary target and add it to the multi target array.
var bool bAllowDeadMultiTargetUnits;
} var bool bExcludeSelfAsTargetIfWithinRadius; (default = false)
- X2AbilityMultiTarget_SoldierBonusRadius{
var name SoldierAbilityName;
} } var float BonusRadius;          //  flat bonus added to normal fTargetRadius


var X2AbilityPassiveAOEStyle AbilityPassiveAOEStyle;


//------------Ability Triggers------------
//Most of the time, actions are triggered directly by player input, but ability triggers (X2AbilityTrigger) can also listen for particular events to occur (such as overwatch waiting for an enemy to move within LOS).


var array<X2AbilityTrigger>{ AbilityTriggers;
- X2AbilityTrigger_EndOfMove
- X2AbilityTrigger_Event{
var class EventObserverClass;
} var name MethodName;
- X2AbilityTrigger_EventListener{
} var AbilityEventListener ListenerData;
- X2AbilityTrigger_OnAbilityActivated
- X2AbilityTrigger_Placeholder // Intentionally does nothing. This is for abilities which are used by the system only, as ValidateTemplates would otherwise think there is a problem as a trigger is required.
- X2AbilityTrigger_PlayerInput //Comment: empty but used
- X2AbilityTrigger_SustainedEffect
- X2AbilityTrigger_UnitPostBeginPlay{
} } var int Priority; (default = 50)
function AddAbilityEventListener(name EventID, delegate<X2TacticalGameRulesetDataStructures.AbilityEventDelegate> EventFn, optional EventListenerDeferral Deferral = ELD_Immediate, optional AbilityEventFilter Filter = eFilter_Unit)


var bool bAllowFreeFireWeaponUpgrade; //  if true, this ability will process the free fire weapon upgrade to spare an action point cost
var bool bAllowAmmoEffects; //  if true, equipped ammo will apply its effects to the target
var bool bAllowBonusWeaponEffects; //  if true, the ability's weapon's bonus effects will be added to the target (in TypicalAbility_BuildGameState)
var bool bCommanderAbility;
var bool bUseThrownGrenadeEffects;
var bool bUseLaunchedGrenadeEffects;
var bool bHideWeaponDuringFire; //  identify ability as a thrown weapon that should be hidden since it's replaced by a projectile during the fire process
var bool bHideAmmoWeaponDuringFire; //
var bool bIsASuppressionEffect; // used to identify suppression type abilities that should use the modified spread during unified projectile processing
var array<AbilityEventListener> AbilityEventListeners;
var EAbilityHostility Hostility;
var bool bAllowedBydefault; //  if true, this ability will be enabled by default. Otherwise the ability will have to be enabled before it is usable
var array<name> OverrideAbilities; //  if set, will replace the first matched ability if it would otherwise be given to a unit
var bool bOverrideAim;
var bool bUseSourceLocationZToAim; //  if set, the unit will aim the attack at the same height as the weapon instead at the target location, must set bOverrideAim to use.
var bool bUniqueSource; //  the ability may only be attached to a unit from one source (see GatherUnitAbilitiesForInit on how that works)
var bool bOverrideWeapon; //  if OverrideAbility is set, the weapon from that ability will be used unless this field is set true.
var array<name> AdditionalAbilities; //  when a unit is granted this ability, it will be granted all of these abilities as well
var array<name> PrerequisiteAbilities; //  if this ability is a modifier on another ability, its listed here. purely informational, mainly for Psi Op ability training.
var bool bStationaryWeapon; //  if the ability uses a cosmetic attached weapon (e.g. gremlin), don't move it to the target when the ability activates
var array<name> PostActivationEvents; //  trigger these events after AbilityActivated is triggered (only when not interrupted) EventData=ability state, EventSource=owner unit state
var bool bRecordValidTiles; //  TypicalAbility_BuildGameState will record the multi target GetValidTilesForLocation in the result context's RelevantEffectTiles
var array<name> AssociatedPassives; //  Set of PurePassive abilities that the unit could have that would modify the behavior of this ability when the unit has them
var bool bIsPassive; //  Flag to identify this as a PurePassive ability later on
var bool bCrossClassEligible; //  Flag for soldier abilities eligible for AWC talent or training roulette
var EConcealmentRule ConcealmentRule;
var bool bSilentAbility; //  Don't trigger sound when this ability is activated, regardless of ammo/damage rules.
var bool bCannotTeleport; // For pathing abilities, prevents ability to use teleport traversals.
var bool bPreventsTargetTeleport; // If set, this ability prevents the target from teleporting away.


var class<X2Action_Fire> ActionFireClass; //Comment: Some classes related, not sure how it works but seems to have a link with visualization


var name FinalizeAbilityName; // certain abilities (such as hack) work as a two step process. Specify the finalizing ability here.
var name CancelAbilityName; // certain abilities (such as hack) work as a two step process. Specify the cancellation ability here.


var bool bCheckCollision; //  Limit affected area because of coliision.
var bool bAffectNeighboringTiles; //  If need to do calculation to figure out what tiles are secondary tile
var bool bFragileDamageOnly; //  Damage fragile only objects.


var bool bCausesCheckFirstSightingOfEnemyGroup; // If true, this ability will cause a CheckFirstSightingOfEnemyGroup on the associated unit


// The strategy requirements that must be met in order for this ability to be used in a tactical mission
var StrategyRequirement Requirements;


//HUD specific items
var localized string LocFriendlyName; // The localized, UI facing name the ability will have
var localized string LocHelpText; // The localized, UI facing description that shows up in the Shot HUD
var localized string LocLongDescription;
var localized string LocPromotionPopupText;
var localized string LocFlyOverText;
var localized string LocMissMessage;
var localized string LocHitMessage;
var localized string LocFriendlyNameWhenConcealed; // used by the shot HUD when the ability owner is concealed
var localized string LocLongDescriptionWhenConcealed; // long description used when ability owner is concealed (ability tooltip)
var localized string LocdefaultPrimaryWeapon; // used in passive effects to indicate the primary weapon for AWC abilities
var EAbilityIconBehavior eAbilityIconBehaviorHUD; // when should this ability appear in the HUD?
var array<name> HideIfAvailable; // if icon behavior is eAbilityIconBehavior_HideIfOtherAvailable, these are the abilities that makes it hide
var array<name> HideErrors; // if icon behavior is eAbilityIconBehavior_HideSpecificErrors, these are the ones to hide
var bool DisplayTargetHitChance; // Indicates this ability's hit chance should be used in the UI as the hit chance on enemies where appropriate.
var bool bUseAmmoAsChargesForHUD; // The ability's weapon's ammo will be displayed as the number of charges available for the ability
var int iAmmoAsChargesDivisor; // Divide the ammo amount by this number to come up with the correct number of charges to be displayed
var string IconImage; // This string identifies which icon the ability will use in the ability container. Can be empty if bAbilityVisibleInHUD is FALSE
var string AbilityIconColor; // background color override for the icon, specified in the RGB hex format "FFFFFF"
var bool bHideOnClassUnlock; // Prevents this ability from showing up in the popup that appears when a soldier gains a new class
var int ShotHUDPriority; // This number is used to sort the icons position in the Ability Container in Tactical HUD. 0 shows up leftmost. 
var bool bNoConfirmationWithHotKey; // True if activation via hotkey should skip the confirmation UI
var bool bLimitTargetIcons; // Will cause the UI to display only valid target icons when this ability is selected.
var bool bBypassAbilityConfirm; // Will force the ability to trigger automatically without requiring the user to click the confirm button.
var Name AbilitySourceName; // Indicates the source of this ability (used to color the icon)
var string AbilityConfirmSound; // Sound to play when choosing to activate the ability in the shot HUD (UI confirmation sound)
var bool bDontDisplayInAbilitySummary; // If true, this ability template will never be displayed as part of an ability summary


//Visualization parameters
var name CustomFireAnim;
var name CustomFireKillAnim;
var name CustomMovingFireAnim;
var name CustomMovingFireKillAnim;
var name CustomMovingTurnLeftFireAnim;
var name CustomMovingTurnLeftFireKillAnim;
var name CustomMovingTurnRightFireAnim;
var name CustomMovingTurnRightFireKillAnim;
var name CustomSelfFireAnim;
var bool bShowActivation; // If true, ability will automatically show its name over the activating unit's head when used.
var bool bShowPostActivation; // If true, ability will automatically show its name over the activating unit's head after the end of the actions and the camera has panned back.
var bool bSkipFireAction; // If true, ability will not exit cover/fire/enter cover when activated.
var bool bSkipExitCoverWhenFiring; // If true, ability will not exit cover when firing is activated.
var bool bSkipPerkActivationActions; // If true, ability will not automatically include perk actions when activated (but will still do the perk duration ending action).
var bool bSkipMoveStop; // If true, typical abilities with embedded moves will not play a stop anim before the fire anim. This should be used for custom moving attacks et cetera
var bool bDisplayInUITooltip; // Will only appear in UI info tooltips if this is true 
var bool bDisplayInUITacticalText; // Will only appear in UI tactical text tooltip if this is true 
var name ActivationSpeech; //  TypicalAbility_BuildVisualization will automatically use these
var name SourceHitSpeech; //  TypicalAbility_BuildVisualization will automatically use these
var name TargetHitSpeech; //  TypicalAbility_BuildVisualization will automatically use these
var name SourceMissSpeech; //  TypicalAbility_BuildVisualization will automatically use these
var name TargetMissSpeech; //  TypicalAbility_BuildVisualization will automatically use these


var class<X2TargetingMethod> TargetingMethod; // UI interaction class. Specifies how the target is actually selected by the user
//Comment: Several classes related, not sure if it usefull for modding
var bool SkipRenderOfAOETargetingTiles; // Modifier to UI interaction class
var bool SkipRenderOfTargetingTemplate; // Modifier to UI interaction class
var bool bOverrideMeleeDeath; // If true it will play a normal death instead of melee death (only effects melee weapons)
var bool bOverrideVisualResult; // Use the below value if this is true
var EAbilityHitResult OverrideVisualResult; // Use this value when checking IsVisualHit instead of the context's actual result


var string MeleePuckMeshPath; // Path of the static mesh to use as the end of path puck when targeting this ability. Only applies to Melee


//Camera settings
var string CinescriptCameraType; // Type of camera to play when this ability is visualized. See defaultcameras.ini
var ECameraPriority CameraPriority; // Override for the priority of the camera used to frame this ability


// note: don't check the following two things directly, you should normally check XComGameStateContext_Ability::ShouldFrameAbility()
var bool bUsesFiringCamera; // Used by the UI / targeting code to know whether the targeting camera should be popped from the camera stack, or left on for the firing camera to use
var ECameraFramingType FrameAbilityCameraType; // Indicates how this ability will use a frame ability camera to look at the source of the ability when it is used
var bool bFrameEvenWhenUnitIsHidden; // Indicates whether this ability will use a frame ability camera to look at the source of the ability when it is used if the unit is not visible (i.e. in fog)


var name TwoTurnAttackAbility; // Name of attack ability if this is a two-turn attack - used for AI.


var int defaultKeyBinding; // Number as found in UIUtilities_Input for the default keyboard binding


var array<UIAbilityStatMarkup> UIStatMarkups; //  Values to display in the UI to modify soldier stats


var delegate<BuildNewGameStateDelegate> BuildNewGameStateFn; // This method converts an input context into a game state
var delegate<BuildInterruptGameStateDelegate> BuildInterruptGameStateFn; // Responsible for creating 'interrupted' and 'resumed' game states if an ability can be interrupted
var delegate<BuildVisualizationDelegate> BuildVisualizationFn; // This method converts a game state into a set of visualization tracks
var delegate<BuildVisualizationSyncDelegate> BuildAppliedVisualizationSyncFn; // This method converts a game load state into a set of visualization tracks
var delegate<BuildVisualizationSyncDelegate> BuildAffectedVisualizationSyncFn; // This method converts a game load state into a set of visualization tracks
var delegate<OnSoldierAbilityPurchased> SoldierAbilityPurchasedFn;
var delegate<OnVisualizationTrackInserted> VisualizationTrackInsertedFn; // This method allows a visualization track that has been brought forward to modify existing tracks after being inserted into the visualization array.
var delegate<ModifyActivatedAbilityContext> ModifyNewContextFn;
var delegate<DamagePreviewDelegate> DamagePreviewFn;


delegate XComGameState BuildNewGameStateDelegate(XComGameStateContext Context);
delegate XComGameState BuildInterruptGameStateDelegate(XComGameStateContext Context, int InterruptStep, EInterruptionStatus InterruptionStatus);
delegate BuildVisualizationDelegate(XComGameState VisualizeGameState, out array<VisualizationTrack> OutVisualizationTracks);
delegate BuildVisualizationSyncDelegate(name EffectName, XComGameState VisualizeGameState, out VisualizationTrack BuildTrack);
delegate OnSoldierAbilityPurchased(XComGameState NewGameState, XComGameState_Unit UnitState);
delegate OnVisualizationTrackInserted(out array<VisualizationTrack> VisualizationTracks, XComGameStateContext_Ability Context, int OuterIndex, int InnerIndex);
delegate ModifyActivatedAbilityContext(XComGameStateContext Context);
delegate bool DamagePreviewDelegate(XComGameState_Ability AbilityState, StateObjectReference TargetRef, out WeaponDamageValue MinDamagePreview, out WeaponDamageValue MaxDamagePreview, out int AllowsShield);


function InitAbilityForUnit(XComGameState_Ability AbilityState, XComGameState_Unit UnitState, XComGameState NewGameState)


function XComGameState_Ability CreateInstanceFromTemplate(XComGameState NewGameState)


function AddTargetEffect(X2Effect Effect)
function AddMultiTargetEffect(X2Effect Effect)
function AddShooterEffect(X2Effect Effect)


function AddAbilityEventListener(name EventID, delegate<X2TacticalGameRulesetDataStructures.AbilityEventDelegate> EventFn, optional EventListenerDeferral Deferral = ELD_Immediate, optional AbilityEventFilter Filter = eFilter_Unit)






































//-------------------------------------------------------------------------------------------------
//--------------------------------------- ENUM/STRUCT LIST ----------------------------------------
//-------------------------------------------------------------------------------------------------


enum EAbilityHostility{
eHostility_Offensive,
eHostility_Defensive,
eHostility_Neutral,
eHostility_Movement,};


enum EConcealmentRule{          //  Checked after the ability is activated to determine if the unit can remain concealed.
eConceal_NonOffensive,      //  Always retain Concealment if the Hostility != Offensive (default behavior)
eConceal_Always,            //  Always retain Concealment, period
eConceal_Never,             //  Never retain Concealment, period
eConceal_KillShot,          //  Retain concealment when killing a single (primary) target
eConceal_Miss,              //  Retain concealment when the ability misses
eConceal_MissOrKillShot,}    //  Retain concealment when the ability misses or when killing a single (primary) target}


enum ECameraFramingType{
eCameraFraming_Never,
eCameraFraming_Always,
eCameraFraming_IfNotNeutral};


struct native UIAbilityStatMarkup{
var() int StatModifier;
var() bool bForceShow; // If true, this markup will display even if the modifier is 0
var() localized string StatLabel; // The user-friendly label associated with this modifier
var() ECharStatType StatType; // The stat type of this markup (if applicable)
var() delegate<X2StrategyGameRulesetDataStructures.SpecialRequirementsDelegate> ShouldStatDisplayFn;} // A function to check if the stat should be displayed or not


// "mccordrm" means that those comments are from his post on the nexus forum: "Looking for better eStat explanations"
//eStat_HighCoverConcealment is on his post but not there... (why? and where is it so??)
enum ECharStatType{
eStat_Invalid,
eStat_UtilityItems, //mccordrm: Number of Utility Items your soldier can carry before equipment bonuses.
eStat_HP, //mccordrm: Hit Points your soldier has. How much damage your soldier can take before dying or bleeding out.
eStat_Offense, //mccordrm: This is your innate "Aim" stat; chance to hit an enemy before modifiers are applied.
eStat_Defense, //mccordrm: Applies a negative percentage to an enemy's (Aim) chance to hit you.
eStat_Mobility, //mccordrm: How many tiles your soldier can move.
eStat_Will, //mccordrm: Mental defense against Psi attacks, getting panicked, etc.
eStat_Hacking, // Used in calculating chance of success for hacking attempts.
eStat_SightRadius, //mccordrm: Your soldier's awareness on the battlefield. If Zero, you'll stay surrounded by the Fog of War unable to do anything but run around in the dark.
eStat_FlightFuel, //mccordrm: Irrelevant at the moment. Feel free to leave at 0.
eStat_AlertLevel, //mccordrm: Only used for enemy AI; ignore for XCom soldiers.
eStat_BackpackSize, //mccordrm: Irrelevant stat, used by the game to place temporary items-- loot picked up after killing an alien, etc.
eStat_Dodge, //mccordrm: Base chance to Dodge an attack, making it a "Graze" instead of a "Hit"
eStat_ArmorChance, //mccordrm: If you apply Armor Mitigation to a soldier, the percentage chance that it gets triggered when attacked.
eStat_ArmorMitigation, //mccordrm: How much innate armor you give a soldier. Can be VERY unbalancing.
eStat_ArmorPiercing,
eStat_PsiOffense, //mccordrm: Same as Offense, but for Psi attacks. Worthless to non-Psi soldiers.
eStat_HackDefense, // Units use this when defending against hacking attempts.
eStat_DetectionRadius, // The radius at which this unit will detect other concealed units. Overall Detection Range = 
eStat_DetectionModifier, // The modifier this unit will apply to the range at which other units can detect this unit. Detector.DetectionRadius * (1.0 - Detectee.DetectionModifier)
eStat_CritChance, //mccordrm: The soldier's base chance to score a Crit before abilities and equipment are figured in.
eStat_Strength, //mccordrm: Used during a melee attack to determine whether a secondary effect (like Stun) is successful.
eStat_SeeMovement,
eStat_HearingRadius, //mccordrm: How far an enemy AI can hear events-- gunshots, grenade blasts, etc.
eStat_CombatSims, //mccordrm: Let's you apply bonus points to another Stat.
eStat_FlankingCritChance, //mccordrm: Gives you the amount as a bonus percentage to your Chance to score a Crit if Flanking an enemy.
eStat_ShieldHP, //mccordrm: If a shield is active, how many hits it can take.
eStat_Job,
} eStat_FlankingAimBonus, //mccordrm: Gives you the amount as a bonus percentage to your Aim if Flanking an enemy.


enum EValueCheck{
eCheck_Exact,
eCheck_RangeInclusive,          // Does the value match the min or max?
eCheck_RangeExclusive,          // Value is within the min or max but not at their values
eCheck_GreaterThan,             // Checks the Max value
eCheck_GreaterThanOrEqual,      // Checks the Max value
eCheck_LessThan,                // Checks the Min value
eCheck_LessThanOrEqual}          // Checks the Min value


struct native CheckConfig{
var EValueCheck     CheckType;
var int             Value;
var int             ValueMin;   // Used for Range
} var int             ValueMax;   // Used for Range;


enum EInventorySlot{
eInvSlot_Unknown,
eInvSlot_Armor,
eInvSlot_PrimaryWeapon,
eInvSlot_SecondaryWeapon,
eInvSlot_HeavyWeapon,
eInvSlot_Utility,
eInvSlot_Mission,
eInvSlot_Backpack,
eInvSlot_Loot,
eInvSlot_GrenadePocket,
eInvSlot_CombatSim,
} eInvSlot_AmmoPocket,


enum UnitInterationType{
eInteractionType_Normal, // not hackable, etc. Just plain vanillia interaction
} eInteractionType_Hack,   // only objects that require hacking to unlock


struct ActionPointCheck{
var name            ActionPointType;
var bool            bCheckReserved;
} var CheckConfig     ConfigValue;


struct native EffectReason{
var name EffectName;
} var name Reason;


struct CheckStat{
var ECharStatType   StatType;
var CheckConfig     ConfigValue;
} var bool            bCheckAsPercent;


struct CheckValue{
var name            UnitValue;
var CheckConfig     ConfigValue;
} var name            OptionalOverrideFalureCode;


enum ECoverType{ //Comment: That thing is in \Steam\steamapps\common\XCOM 2 SDK\Development\Src\Engine\Classes\Scout.uc
CT_None, /** default, no cover */
CT_MidLevel, /** Mid-level crouch cover, stand to fire */
} CT_Standing, /** Full standing cover */


struct ApplyDamageInfo{
var WeaponDamageValue BaseDamageValue;
var WeaponDamageValue ExtraDamageValue;
var WeaponDamageValue BonusEffectDamageValue;
var WeaponDamageValue AmmoDamageValue;
var WeaponDamageValue UpgradeDamageValue;
} var bool bDoesDamageIgnoreShields;


enum EGameplayBlocking{
eGameplayBlocking_DoesNotModify,
eGameplayBlocking_DoesNotBlock,
} eGameplayBlocking_Blocks,


enum EDuplicateEffect{
eDupe_Allow,        //  new effect is added and tracked separately from the old effect
eDupe_Refresh,      //  current effect's duration is reset    
} eDupe_Ignore,       //  new effect is not added and old effect is unchanged


struct EffectHitModifier{
var class<X2AbilityToHitCalc>   MatchToHit;
var ShotModifierInfo Modifier;
var bool bApplyToMelee, bApplyToNonMelee;
var bool bApplyToFlankedTarget, bApplyToNonFlankedTarget;
var array<name> AbilitiesAppliedTo;
} var bool bApplyIfImpaired;


enum EAbilityIconBehavior{
eAbilityIconBehavior_AlwaysShow,
eAbilityIconBehavior_ShowIfAvailable,
eAbilityIconBehavior_NeverShow,
eAbilityIconBehavior_HideIfOtherAvailable,      //  only hides if another named ability is available, otherwise acts as AlwaysShow
eAbilityIconBehavior_ShowIfAvailableOrNoTargets,
} eAbilityIconBehavior_HideSpecificErrors,        //  another field will specify which errors should hide the icon


// ABILITY PRIORITIES top -> bottom == left -> right
// 0 is reserved for reload, when it's available
// NOTE: the values are base 10 to allow for addition of new abilities without having to re-prioritize everything
/*Template.ShotHUDPriority =*/
const MUST_RELOAD_PRIORITY = 70;
const STANDARD_SHOT_PRIORITY  = 100;
const OVERWATCH_PRIORITY = 200;
const STANDARD_PISTOL_SHOT_PRIORITY  = 210;
const PISTOL_OVERWATCH_PRIORITY = 220;
const OBJECTIVE_INTERACT_PRIORITY  = 230;
const EVAC_PRIORITY = 240;
const CLASS_SQUADDIE_PRIORITY = 310;
const CLASS_CORPORAL_PRIORITY = 320;
const CLASS_SERGEANT_PRIORITY = 330;
const CLASS_LIEUTENANT_PRIORITY = 340;
const CLASS_CAPTAIN_PRIORITY = 350;
const CLASS_MAJOR_PRIORITY = 360;
const CLASS_COLONEL_PRIORITY = 370;
const HUNKER_DOWN_PRIORITY  = 400;
const INTERACT_PRIORITY  = 500;
const HACK_PRIORITY  = 600;
const LOOT_PRIORITY  = 700;
const RELOAD_PRIORITY  = 800; // Reload should come after class abilities, but before item abilities
const STABILIZE_PRIORITY = 900;
const MEDIKIT_HEAL_PRIORITY = 1000;
const COMBAT_STIMS_PRIORITY = 1100;
const UNSPECIFIED_PRIORITY  = 1200;
const STANDARD_GRENADE_PRIORITY  = 1300;
const ALIEN_GRENADE_PRIORITY  = 1400;
const FLASH_BANG_PRIORITY  = 1500;
const FIREBOMB_PRIORITY = 1600;
const STASIS_LANCE_PRIORITY = 1700;
const ARMOR_ACTIVE_PRIORITY = 1800;


// commander abilities must be placed after normal ability priorities
const PLACE_EVAC_PRIORITY = 2000;








/**X2AbilityTemplate DefaultProperties*/
{
Begin Object Class=X2AbilityToHitCalc_DeadEye Name=DefaultDeadEye
End Object
DeadEye = DefaultDeadEye;


Begin Object Class=X2AbilityToHitCalc_StandardAim Name=DefaultSimpleStandardAim
End Object
SimpleStandardAim = DefaultSimpleStandardAim;


Begin Object Class=X2Condition_UnitProperty Name=DefaultLivingShooterProperty
ExcludeAlive=false
ExcludeDead=true
ExcludeFriendlyToSource=false
ExcludeHostileToSource=true
End Object
LivingShooterProperty = DefaultLivingShooterProperty;


Begin Object Class=X2Condition_UnitProperty Name=DefaultLivingHostileTargetProperty
ExcludeAlive=false
ExcludeDead=true
ExcludeFriendlyToSource=true
ExcludeHostileToSource=false
TreatMindControlledSquadmateAsHostile=true
End Object
LivingHostileTargetProperty = DefaultLivingHostileTargetProperty;


Begin Object Class=X2Condition_UnitProperty Name=DefaultLivingHostileUnitOnlyProperty
ExcludeAlive=false
ExcludeDead=true
ExcludeFriendlyToSource=true
ExcludeHostileToSource=false
TreatMindControlledSquadmateAsHostile=true
FailOnNonUnits=true
End Object
LivingHostileUnitOnlyProperty = DefaultLivingHostileUnitOnlyProperty;


Begin Object Class=X2Condition_UnitProperty Name=DefaultLivingHostileUnitDisallowMindControlProperty
ExcludeAlive=false
ExcludeDead=true
ExcludeFriendlyToSource=true
ExcludeHostileToSource=false
TreatMindControlledSquadmateAsHostile=false
FailOnNonUnits=true
End Object
LivingHostileUnitDisallowMindControlProperty = DefaultLivingHostileUnitDisallowMindControlProperty;


Begin Object Class=X2Condition_UnitProperty Name=DefaultLivingTargetUnitOnlyProperty
ExcludeAlive=false
ExcludeDead=true
ExcludeFriendlyToSource=false
ExcludeHostileToSource=false
FailOnNonUnits=true
End Object
LivingTargetUnitOnlyProperty = DefaultLivingTargetUnitOnlyProperty;


Begin Object Class=X2AbilityTrigger_PlayerInput Name=DefaultPlayerInputTrigger
End Object
PlayerInputTrigger = DefaultPlayerInputTrigger;


Begin Object Class=X2AbilityTrigger_UnitPostBeginPlay Name=DefaultUnitPostBeginPlayTrigger
End Object
UnitPostBeginPlayTrigger = DefaultUnitPostBeginPlayTrigger;


Begin Object Class=X2AbilityTarget_Self Name=DefaultSelfTarget
End Object
SelfTarget = DefaultSelfTarget;


Begin Object Class=X2AbilityTarget_Single Name=DefaultSimpleSingleTarget
bAllowDestructibleObjects=true
End Object
SimpleSingleTarget = DefaultSimpleSingleTarget;


Begin Object Class=X2AbilityTarget_Single Name=DefaultSimpleSingleMeleeTarget
bAllowDestructibleObjects=true
OnlyIncludeTargetsInsideWeaponRange=true
End Object
SimpleSingleMeleeTarget = DefaultSimpleSingleMeleeTarget;


Begin Object Class=X2AbilityTarget_Single Name=DefaultSingleTargetWithSelf
bIncludeSelf=true
End Object
SingleTargetWithSelf = DefaultSingleTargetWithSelf;


Begin Object Class=X2Condition_Visibility Name=DefaultGameplayVisibilityCondition
bRequireGameplayVisible=true
bRequireBasicVisibility=true
End Object
GameplayVisibilityCondition = DefaultGameplayVisibilityCondition;


Begin Object Class=X2Condition_Visibility Name=DefaultMeleeVisibilityCondition
bRequireGameplayVisible=true
bVisibleToAnyAlly=true
End Object
MeleeVisibilityCondition = DefaultMeleeVisibilityCondition;


Begin Object Class=X2AbilityCost_ActionPoints Name=DefaultFreeActionCost
iNumPoints=1
bFreeCost=true
End Object
FreeActionCost = DefaultFreeActionCost;


Begin Object Class=X2Effect_ApplyWeaponDamage Name=DefaultWeaponUpgradeMissDamage
bApplyOnHit=false
bApplyOnMiss=true
bIgnoreBaseDamage=true
DamageTag="Miss"
bAllowWeaponUpgrade=true
End Object
WeaponUpgradeMissDamage = DefaultWeaponUpgradeMissDamage;


CounterattackDodgeEffectName = "CounterattackDodgeEffect"
CounterattackDodgeUnitValue = 1
}

Edited April 5, 2016 by AlexCheux

jgbaxter · April 3, 2016

I'm a fan!

Not sure I'll go back and change things now though. :)

AlexCheux · April 4, 2016

Thx ;)

XCOM

X2AbilityTemplate: (almost) full content for a better use

Recommended Posts

AlexCheux

Link to comment

Share on other sites

jgbaxter

Link to comment

Share on other sites

AlexCheux

Link to comment

Share on other sites

Recently Browsing 0 members

Browse

Activity

My Activity Streams

Explore