rohan/XCom2-RWRealisticAimingAnglesHL - Change JSCVVDFDJPB44MYIIERF62A6R7G5I5NDGLXFTL43TP6T4OFREQHAC

remove commented code and excess tabs

Created by rohan on August 27, 2022

JSCVVDFDJPB44MYIIERF62A6R7G5I5NDGLXFTL43TP6T4OFREQHAC

Dependencies

[2] X4IR7ZAH5HH56FIYSSOUKOQDRLNKH5LOHQ5ZYQGQQLML67RLZGMQC

In channels

main

Change contents

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1 [2.20224]

B:BD[2.20224] → [2.20225:20402]

class Override_X2AbilityToHitCalc_StandardAim
extends		   X2AbilityToHitCalc_StandardAim
config (RWRealisticAimingAngles);
//extends X2AbilityToHitCalc
//config(GameCore);

[2.20224]

[2.20402]

class Override_X2AbilityToHitCalc_StandardAim extends X2AbilityToHitCalc_StandardAim config (RWRealisticAimingAngles);

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 7 [2.20224]
B:BD[2.20755] → [2.20755:20907]
B:BD[2.20907] → [2.20907:20909]
```
/*
;PERFECT INFORMATION: MID-ACTION TEXT
ShowChances = true
ShowCriticalAndDodgeChances = true
ShowDiceRolls = true
ShowOnlyForAllies = false
*/
```
Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 28 [2.20224]
B:BD[2.22309] → [2.22309:22342]
```
var        float FarCoverBonus;
```
[2.22309]
[2.22342]
```
var float FarCoverBonus;
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 30 [2.20224]

B:BD[2.22344] → [2.22344:22476]

var		   bool ShowChances;
var		   bool ShowCriticalAndDodgeChances;
var		   bool ShowDiceRolls;
var		   bool ShowOnlyForAllies;

[2.22344]

[2.22476]

var bool ShowChances;
var bool ShowCriticalAndDodgeChances;
var bool ShowDiceRolls;
var bool ShowOnlyForAllies;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 35 [2.20224]

B:BD[2.22478] → [2.22478:22814]

var		   bool UseIndividualConsecutiveRollsForHitChanceCriticalChanceDodgeChance;
var		   bool PrioritizeCriticalChanceOverDodgeChance;
var		   bool AlwaysRollForBothDodgeAndCriticalEvenWhenOneUnsuccesful;
var		   bool GuaranteedHitsCannotDodge;
var		   bool IndirectFireGuaranteesHit;
var		   bool EnableGamblerFallacySystemRoll;

[2.22478]

[2.22814]

var bool UseIndividualConsecutiveRollsForHitChanceCriticalChanceDodgeChance;
var bool PrioritizeCriticalChanceOverDodgeChance;
var bool AlwaysRollForBothDodgeAndCriticalEvenWhenOneUnsuccesful;
var bool GuaranteedHitsCannotDodge;
var bool IndirectFireGuaranteesHit;
var bool EnableGamblerFallacySystemRoll;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 44 [2.20224]

B:BD[2.22847] → [2.22847:22849]

B:BD[2.22849] → [2.22849:23432]


//static function StaticInternalRollForAbilityHit(X2AbilityToHitCalc_StandardAim Aim, XComGameState_Ability kAbility, AvailableTarget kTarget, bool bIsPrimaryTarget, const out AbilityResultContext ResultContext, out EAbilityHitResult Result, out ArmorMitigationResults ArmorMitigated, out int HitChance)
         function	    InternalRollForAbilityHit(									  XComGameState_Ability kAbility, AvailableTarget kTarget, bool bIsPrimaryTarget, const out AbilityResultContext ResultContext, out EAbilityHitResult Result, out ArmorMitigationResults ArmorMitigated, out int HitChance)

[2.22847]

[2.23432]

function InternalRollForAbilityHit(XComGameState_Ability kAbility, AvailableTarget kTarget, bool bIsPrimaryTarget, const out AbilityResultContext ResultContext, out EAbilityHitResult Result, out ArmorMitigationResults ArmorMitigated, out int HitChance)

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 61 [2.20224]

B:BD[2.23992] → [2.23992:24136]

	local		int		OriginalHitRoll;
	local		float	DodgeChance;
	local		String  AbilityName;
	local		String  TargetName;
	local	    bool	IsAlien;

[2.23992]

[2.24136]

	local int OriginalHitRoll;
	local float DodgeChance;
	local String AbilityName;
	local String TargetName;
	local bool IsAlien;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 67 [2.20224]
B:BD[2.24168] → [2.24168:24261]
```
	local		int		RealHitChance;
	local		int		TotalHitChance;
	local		string  DebugRollOutput;
```
[2.24168]
[2.24261]
```
	local int RealHitChance;
	local int TotalHitChance;
	local string DebugRollOutput;
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 95 [2.20224]
B:BD[2.25135] → [2.25135:25222]
```
		//	if( !`CHEATMGR.bXComOnlyDeadEye || !UnitState.ControllingPlayerIsAI()							   )
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 107 [2.20224]
B:BD[2.25633] → [2.25633:25717]
```
//																							 RandRoll = `SYNC_RAND_TYPED(100, ESyncRandType_Generic);
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 321 [2.20224]
B:BD[2.34998] → [2.34998:35112]
```
//									 UnitState = XComGameState_Unit(History.GetGameStateForObjectID(kAbility.OwnerStateObject.ObjectID));
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 322 [2.20224]
B:BD[2.35304] → [2.35304:35416]
```
//									 TargetState = XComGameState_Unit(History.GetGameStateForObjectID(kTarget.PrimaryTarget.ObjectID));
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 497 [2.20224]

B:BD[2.41931] → [2.41931:42095]

/*	if (default.UseIndividualConsecutiveRollsForHitChanceCriticalChanceDodgeChance) */ NotifyEventList(kAbility, kTarget, PINotify, !IsAlien); //ADDED THIS LINE!!!

[2.41931]

[2.42095]

        NotifyEventList(kAbility, kTarget, PINotify, !IsAlien); //ADDED THIS LINE!!!

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 573 [2.20224]

B:BD[2.45237] → [2.45237:46120]

	local TTile 						ShooterTile;
	local TTile 						TargetTile;
	local TTile 						ShooterHead;
	local TTile 						TargetHead;
	local TTile 						ShooterTorso;
//	local TTile 						TargetTorso;
	local TTile 						TargetLegs;
	local TTile 						ShooterBelowFeet;
	local float 						ShooterTargetDistance;
	local float 						ShooterHeadRelativeElevation;
	local float							VerticalAngle;
	local float 						GoodAngleBonus;
	local float 						ExtendedLowCoverPreventingGoodAngleBonus;
	local float 						HeightAdvantageBonus;	 //ALWAYS FLOATS INSTEAD OF INTS!!!!
	local float							HeightDisadvantageMalus; //OR YOU WILL LOOSE HOURS TRYING TO UNDERSTAND WHY
	local float							NoLineOfSightMalus;		 //THEY DIDN'T APPLY MULTIPLIERS!!! BECAUSE INT AUTO-ROUND!!! MOTHERFUCKERS!!!
	local string						FarCoverText;
	local TTile							NextTile;
	local int 							FarCover;

[2.45237]

[2.46120]

	local TTile ShooterTile;
	local TTile TargetTile;
	local TTile ShooterHead;
	local TTile TargetHead;
	local TTile ShooterTorso;
	local TTile TargetLegs;
	local TTile ShooterBelowFeet;
	local float ShooterTargetDistance;
	local float ShooterHeadRelativeElevation;
	local float VerticalAngle;
	local float GoodAngleBonus;
	local float ExtendedLowCoverPreventingGoodAngleBonus;
	local float HeightAdvantageBonus;	 //ALWAYS FLOATS INSTEAD OF INTS!!!!
	local float HeightDisadvantageMalus; //OR YOU WILL LOOSE HOURS TRYING TO UNDERSTAND WHY
	local float NoLineOfSightMalus;		 //THEY DIDN'T APPLY MULTIPLIERS!!! BECAUSE INT AUTO-ROUND!!! MOTHERFUCKERS!!!
	local string FarCoverText;
	local TTile NextTile;
	local int FarCover;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 592 [2.20224]

B:BD[2.46174] → [2.46174:46356]

//	local XComGameState					NewGameStateForDestructibleObject;
//	local XComGameState_Destructible	TargetStateDestructibleObject;
	local ECoverType					CoverTypeOfTileAboveTarget;

[2.46174]

[2.46356]

	local ECoverType CoverTypeOfTileAboveTarget;

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 603 [2.20224]
B:BD[2.46762] → [2.46762:46911]
```
//	ShooterLocation = `XWORLD.GetPositionFromTileCoordinates(ShooterTile);
//	TargetLocation  = `XWORLD.GetPositionFromTileCoordinates(TargetTile);
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 606 [2.20224]

B:BD[2.47128] → [2.47128:47328]

	CoverTypeOfTileAboveTarget = CoverTypeOfTileAboveCover		 (ShooterTile, TargetTile, VisInfo.TargetCoverAngle);
	NextTileOverCoverType	   = NextTileOverCoverInSameDirection(ShooterTile, TargetTile);

[2.47128]

[2.47328]

	CoverTypeOfTileAboveTarget = CoverTypeOfTileAboveCover(ShooterTile, TargetTile, VisInfo.TargetCoverAngle);
	NextTileOverCoverType = NextTileOverCoverInSameDirection(ShooterTile, TargetTile);

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 628 [2.20224]

B:BD[2.48081] → [2.48081:48236]

		super					 .AddModifier(100, AbilityTemplate.LocFriendlyName, m_ShotBreakdown, eHit_Success, bDebugLog); //WATCHOUT!!! SUPER. IS NOT ANYMORE THE PARENT

[2.48081]

[2.48236]

		super.AddModifier(100, AbilityTemplate.LocFriendlyName, m_ShotBreakdown, eHit_Success, bDebugLog); //WATCHOUT!!! SUPER. IS NOT ANYMORE THE PARENT

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 642 [2.20224]

B:BD[2.48850] → [2.48850:50325]


		//ADDED THIS PARAGRAPH!!! (GUARANTEED HIT MY ASS...)
	/*	TargetingObjectsRealisticallyAllowsToMissThemAndUsesConventionalHitChanceStatsPlusThisAimingBonus = 15
		if(default.TargetingObjectsRealisticallyAllowsToMissThemAndUsesConventionalHitChanceStatsPlusThisAimingBonus != 100) {
			TargetStateDestructibleObject = XComGameState_Destructible(History.GetGameStateForObjectID( kTarget.PrimaryTarget.ObjectID ));
			NewGameStateForDestructibleObject = class'XComGameStateContext_ChangeContainer'.static.CreateChangeState("Conversion From Unit to Destructible for Aiming Stats");
			TargetState = XComGameState_Unit(NewGameStateForDestructibleObject.CreateNewStateObject(class'XComGameState_Unit'));
			TargetState.SetVisibilityLocation(TargetStateDestructibleObject.TileLocation); //KEYSTONEVISIBILITYLOCATION EVEN FOR OBJECTS??? REMEMBER HOW .TILELOCATION WAS BUGGY FOR UNITS!!!!
			AddModifier(default.TargetingObjectsRealisticallyAllowsToMissThemAndUsesConventionalHitChanceStatsPlusThisAimingBonus, class'XLocalizedData'.default.DefenseStat, m_ShotBreakdown, eHit_Success, bDebugLog);}
		else {
	*/	//END OF ADDED PARAGRAPH!!!
			// when targeting non-units, we have a 100% chance to hit. They can't dodge or otherwise
			// mess up our shots
			m_ShotBreakdown.HideShotBreakdown = true;
			AddModifier(100																										 , class'XLocalizedData'.default.OffenseStat, m_ShotBreakdown, eHit_Success, bDebugLog);
	//	} //ADDED THIS LINE!!!

[2.48850]

[2.50325]

	    // when targeting non-units, we have a 100% chance to hit. They can't dodge or otherwise
	    // mess up our shots
	    m_ShotBreakdown.HideShotBreakdown = true;
	    AddModifier(100, class'XLocalizedData'.default.OffenseStat, m_ShotBreakdown, eHit_Success, bDebugLog);

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 740 [2.20224]

B:BD[2.54964] → [2.54964:55244]


							//`assert(VisInfo.TargetCoverAngle >= 0); // if the target has cover, the target cover angle should always be greater than 0
						//	if( VisInfo.TargetCoverAngle < MAX_ANGLE_TO_COVER																		   &&  TileDistance <= MAX_TILE_DISTANCE_TO_COVER														   )

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 742 [2.20224]

B:BD[2.55491] → [2.55491:55589]

																											   bShouldAddAngleToCoverBonus = (UnitState.GetTeam() == eTeam_XCom);

[2.55491]

[2.55589]

								bShouldAddAngleToCoverBonus = (UnitState.GetTeam() == eTeam_XCom);

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 747 [2.20224]

B:BD[2.55927] → [2.55927:56267]

							//	if( (SHOULD_DISABLE_BONUS_ON_ANGLE_TO_EXTENDED_LOW_COVER && VisInfo.TargetCover == CT_MidLevel) || (SHOULD_ENABLE_PENALTY_ON_ANGLE_TO_EXTENDED_HIGH_COVER && VisInfo.TargetCover == CT_Standing) )
								if( (true												 && VisInfo.TargetCover == CT_MidLevel) || (false												  && VisInfo.TargetCover == CT_Standing) )

[2.55927]

[2.56267]

								if((true && VisInfo.TargetCover == CT_MidLevel) || (false && VisInfo.TargetCover == CT_Standing))

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 751 [2.20224]

B:BD[2.56420] → [2.56420:56536]

B:BD[2.56536] → [2.56536:56538]

B:BD[2.56538] → [2.56538:57100]

									NextTileOverCoverType	   = NextTileOverCoverInSameDirection(UnitTileLocation, TargetTileLocation							);
								//	if( SHOULD_DISABLE_BONUS_ON_ANGLE_TO_EXTENDED_LOW_COVER	&&  VisInfo.TargetCover == CT_MidLevel										  &&  NextTileOverCoverType == CT_MidLevel										   ) //EXTENDED LOW-HIGH COVER HIBRID
								//	if(true													&& (VisInfo.TargetCover == CT_MidLevel || VisInfo.TargetCover == CT_Standing) && (NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing))
									if(true													&&  VisInfo.TargetCover == CT_MidLevel										  && (NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing))

[2.56420]

[2.57100]

									NextTileOverCoverType = NextTileOverCoverInSameDirection(UnitTileLocation, TargetTileLocation);

Insertion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 753 [2.20224]
[2.57102]
[2.57102]
```
									if(true && VisInfo.TargetCover == CT_MidLevel && (NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing))
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 757 [2.20224]

B:BD[2.57174] → [2.57174:57445]

								//	else if(SHOULD_ENABLE_PENALTY_ON_ANGLE_TO_EXTENDED_HIGH_COVER && VisInfo.TargetCover == CT_Standing && NextTileOverCoverType == CT_Standing )
									else if(false												  && VisInfo.TargetCover == CT_Standing && NextTileOverCoverType == CT_Standing )

[2.57174]

[2.57445]

									else if(false && VisInfo.TargetCover == CT_Standing && NextTileOverCoverType == CT_Standing )

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 760 [2.20224]

B:BD[2.57505] → [2.57505:57801]

										Alpha = FClamp((VisInfo.TargetCoverAngle - MIN_ANGLE_TO_COVER																 ) / (MAX_ANGLE_TO_COVER																   - MIN_ANGLE_TO_COVER																   ), 0.0, 1.0);
										AngleToCoverModifier = Lerp(MAX_ANGLE_PENALTY													 , MIN_ANGLE_PENALTY													, Alpha);

[2.57505]

[2.57801]

										Alpha = FClamp((VisInfo.TargetCoverAngle - MIN_ANGLE_TO_COVER) / (MAX_ANGLE_TO_COVER - MIN_ANGLE_TO_COVER), 0.0, 1.0);
										AngleToCoverModifier = Lerp(MAX_ANGLE_PENALTY, MIN_ANGLE_PENALTY, Alpha);

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 768 [2.20224]

B:BD[2.58035] → [2.58035:58373]

								//	Alpha = FClamp((VisInfo.TargetCoverAngle - MIN_ANGLE_TO_COVER																	 ) / (MAX_ANGLE_TO_COVER																	   - MIN_ANGLE_TO_COVER																	   ), 0.0, 1.0);
								//	Alpha = FClamp((VisInfo.TargetCoverAngle - 0																					 ) / (45																					   - 0																					   ), 0.0, 1.0);

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 769 [2.20224]
B:BD[2.58708] → [2.58708:58822]
```
								//	AngleToCoverModifier = Lerp(MAX_ANGLE_BONUS_MOD										  , MIN_ANGLE_BONUS_MOD										  , Alpha);
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 770 [2.20224]

B:BD[2.58988] → [2.58988:60518]

								//	AngleToCoverModifier = Lerp(1														  , 0														  , Alpha);
																												 //	AddModifier(Round(CoverValue * AngleToCoverModifier) , class'XLocalizedData'.default.AngleToTargetCover, m_ShotBreakdown, eHit_Success, bDebugLog);
																											   GoodAngleBonus = Round(CoverValue * AngleToCoverModifier);
																													AddModifier(GoodAngleBonus							 , class'XLocalizedData'.default.AngleToTargetCover, m_ShotBreakdown, eHit_Success, bDebugLog);
								//	if (VisInfo.TargetCover == CT_Standing && NextTileOverCoverType == CT_MidLevel) AddModifier(-Round(GoodAngleBonus / 2)				 , "ExtendedLowCover preventing GoodAngle"				   , m_ShotBreakdown, eHit_Success, bDebugLog);
								//	if ((VisInfo.TargetCover == CT_MidLevel || VisInfo.TargetCover == CT_Standing) && (NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing)) AddModifier(-Round(GoodAngleBonus / 2)				 , "ExtendedLowCover preventing GoodAngle"				   , m_ShotBreakdown, eHit_Success, bDebugLog);
									if (																			  (NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing)) {
													ExtendedLowCoverPreventingGoodAngleBonus = -Round(GoodAngleBonus / 2);
										AddModifier(ExtendedLowCoverPreventingGoodAngleBonus , "ExtendedLowCover preventing GoodAngle"				   , m_ShotBreakdown, eHit_Success, bDebugLog);} //WHEN ONLY "HALF OF" THE HIGHCOVER IS REDUCED BY THE GOODANGLE BECAUSE THE OTHER HALF IS COVERED BY LOWCOVER... ;)

[2.58988]

[2.60518]

									GoodAngleBonus = Round(CoverValue * AngleToCoverModifier);
									AddModifier(GoodAngleBonus, class'XLocalizedData'.default.AngleToTargetCover, m_ShotBreakdown, eHit_Success, bDebugLog);
									if ((NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing))
									{
										ExtendedLowCoverPreventingGoodAngleBonus = -Round(GoodAngleBonus / 2);
										AddModifier(ExtendedLowCoverPreventingGoodAngleBonus , "ExtendedLowCover preventing GoodAngle", m_ShotBreakdown, eHit_Success, bDebugLog);} //WHEN ONLY "HALF OF" THE HIGHCOVER IS REDUCED BY THE GOODANGLE BECAUSE THE OTHER HALF IS COVERED BY LOWCOVER... ;)

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 781 [2.20224]
B:BD[2.60587] → [2.60587:60675]
```
				//	if (UnitState.HasHeightAdvantageOver(TargetState, true)																							)
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 787 [2.20224]
B:BD[2.61057] → [2.61057:61146]
```
				//	if (TargetState.HasHeightAdvantageOver(UnitState, false)																						 )
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 790 [2.20224]
B:BD[2.61487] → [2.61487:61624]
```
					//	AddModifier(-10																  , class'XLocalizedData'.default.HeightDisadvantage, m_ShotBreakdown, eHit_Success, bDebugLog);
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 795 [2.20224]

B:BD[2.61710] → [2.61710:62411]

				//	PI = 3.141592; //ALMIGHTY UNIVERSAL CONSTANT
				//	ShooterHead		 = ShooterTile;	ShooterHead.Z      += 2;
				//	TargetHead		 = TargetTile;	TargetHead .Z      += 2;
				//	ShooterHead		 = ShooterTile;	ShooterHead.Z      += UnitState  .UnitHeight -1;
				//	TargetHead		 = TargetTile;	TargetHead .Z      += TargetState.UnitHeight -1;
					ShooterHead		 = ShooterTile;	ShooterHead.Z		= `XWORLD.GetFloorTileZ(ShooterHead) + UnitState  .UnitHeight -1;
					TargetHead		 = TargetTile;  TargetHead .Z		= `XWORLD.GetFloorTileZ(TargetHead ) + TargetState.UnitHeight -1;
					ShooterTorso	 = ShooterHead; ShooterTorso.Z     -= 0.5;
				//	TargetTorso		 = TargetHead ; TargetTorso .Z	   -= 0.5;

[2.61710]

[2.62411]

					ShooterHead = ShooterTile; ShooterHead.Z = `XWORLD.GetFloorTileZ(ShooterHead) + UnitState.UnitHeight -1;
					TargetHead = TargetTile;  TargetHead.Z = `XWORLD.GetFloorTileZ(TargetHead ) + TargetState.UnitHeight -1;
					ShooterTorso = ShooterHead; ShooterTorso.Z -= 0.5;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 799 [2.20224]
B:BD[2.62474] → [2.62474:62507]
```
					TargetLegs		 = TargetTile;
```
[2.62474]
[2.62507]
```
					TargetLegs = TargetTile;
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 805 [2.20224]

B:BD[2.62887] → [2.62887:63339]

					if (default.ApplyVerticalGoodAngleAgainstLowerTargetAsProportionalHeightAdvantage	  &&
						ShooterHeadRelativeElevation > 0												  &&
						((VisInfo.TargetCover == CT_MidLevel										 ) ||    //HEIGHT ADVANTAGE REDUCES ONLY LOW COVER .... OR SHOULD IT???
						 (VisInfo.TargetCover == CT_Standing && CoverTypeOfTileAboveTarget == CT_None)	) ){ //...WELL DEPENDS ON WETHER IT'S A VERTICAL TREE OR AN ORIZONTAL HIGHCOVER FENCE... ;)

[2.62887]

[2.63339]

					if (default.ApplyVerticalGoodAngleAgainstLowerTargetAsProportionalHeightAdvantage && ShooterHeadRelativeElevation > 0 && ((VisInfo.TargetCover == CT_MidLevel)    //HEIGHT ADVANTAGE REDUCES ONLY LOW COVER .... OR SHOULD IT???
						|| (VisInfo.TargetCover == CT_Standing && CoverTypeOfTileAboveTarget == CT_None)))
					{ //...WELL DEPENDS ON WETHER IT'S A VERTICAL TREE OR AN ORIZONTAL HIGHCOVER FENCE... ;)

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 810 [2.20224]

B:BD[2.63604] → [2.63604:64250]

						Alpha = FClamp(((90-VerticalAngle) 		 - default.MaximumHeightAdvantageBonusEndsAtThisVerticalAngleBetweenLineOfFireAndCoverSurface) / (default.MinimumHeightAdvantageBonusStartsAtThisVerticalAngleBetweenLineOfFireAndCoverSurface - default.MaximumHeightAdvantageBonusEndsAtThisVerticalAngleBetweenLineOfFireAndCoverSurface), 0.0, 1.0);
					//	Alpha = FClamp((VisInfo.TargetCoverAngle - 0																						 ) / (45																					       - 0																						   ), 0.0, 1.0);
					//	Alpha = FClamp(((90-VerticalAngle) 		 - 30																						 ) / (90																					       - 30																						   ), 0.0, 1.0);

[2.63604]

[2.64250]

						Alpha = FClamp(((90-VerticalAngle) - default.MaximumHeightAdvantageBonusEndsAtThisVerticalAngleBetweenLineOfFireAndCoverSurface) / (default.MinimumHeightAdvantageBonusStartsAtThisVerticalAngleBetweenLineOfFireAndCoverSurface - default.MaximumHeightAdvantageBonusEndsAtThisVerticalAngleBetweenLineOfFireAndCoverSurface), 0.0, 1.0);

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 812 [2.20224]
B:BD[2.64425] → [2.64425:64512]
```
					//	AngleToCoverModifier = Lerp(1															   , 0																  , Alpha);
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 813 [2.20224]

B:BD[2.64584] → [2.64584:64789]

					//	HeightAdvantageBonus = round(VerticalAngle/90	  * CoverValue);
						AddModifier(HeightAdvantageBonus,	 class'XLocalizedData'.default.HeightAdvantage, m_ShotBreakdown, eHit_Success, bDebugLog);}

[2.64584]

[2.64789]

						AddModifier(HeightAdvantageBonus, class'XLocalizedData'.default.HeightAdvantage, m_ShotBreakdown, eHit_Success, bDebugLog);
					}

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 816 [2.20224]

B:BD[2.64791] → [2.64791:66766]

					if (default.GiveHitChanceZeroWhenTargetableEnemiesAreInsteadNotTrulyInLineOfSight// &&
					/*	ShooterHeadRelativeElevation > 0	*/										  ){ //'FAR' COVER BLOCKING VISIBILITY CHECK...
						if (ShooterHead.Z - TargetLegs.Z >= 0){	//SAME HEIGHT OR BELOW SHOOTER
								NextTile = ShooterTile;
								NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (NextTile.Z>=ShooterTile.Z && FarCover>0 && !`XWORLD.CanSeeTileToTile(ShooterTorso, TargetHead, VisibilityInfo)) NoLineOfSightMalus = -1000;
								NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (NextTile.Z>=ShooterTile.Z && FarCover>0 && !`XWORLD.CanSeeTileToTile(ShooterTorso, TargetHead, VisibilityInfo)) NoLineOfSightMalus = -1000; //LOW COVER IN CALCULATING VISIBILITY.
								NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (NextTile.Z>=ShooterTile.Z && FarCover>0 && !`XWORLD.CanSeeTileToTile(ShooterTorso, TargetHead, VisibilityInfo)) NoLineOfSightMalus = -1000;} //THIS NONSENSE HAD TO BE MODDED AWAY...
						if (ShooterHead.Z - TargetLegs.Z < 0){	//ABOVE SHOOTER
								NextTile = ShooterTile;
								NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (FarCover == 1 && !`XWORLD.CanSeeTileToTile(ShooterBelowFeet, TargetLegs, VisibilityInfo)) NoLineOfSightMalus = -1000; //DIFFERENT CHECK FOR HIGH GROUNDS
								NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (FarCover == 1 && !`XWORLD.CanSeeTileToTile(ShooterBelowFeet, TargetLegs, VisibilityInfo)) NoLineOfSightMalus = -1000; //IN CALCULATING VISIBILITY.
								NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (FarCover == 1 && !`XWORLD.CanSeeTileToTile(ShooterBelowFeet, TargetLegs, VisibilityInfo)) NoLineOfSightMalus = -1000;}
						If (NoLineOfSightMalus != 0) AddModifier(NoLineOfSightMalus, "No Line of Sight", m_ShotBreakdown, eHit_Success, bDebugLog);}

[2.64791]

[2.66766]

					if (default.GiveHitChanceZeroWhenTargetableEnemiesAreInsteadNotTrulyInLineOfSight)
					{ //'FAR' COVER BLOCKING VISIBILITY CHECK...
						if (ShooterHead.Z - TargetLegs.Z >= 0) //SAME HEIGHT OR BELOW SHOOTER
						{
							NextTile = ShooterTile;
							NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (NextTile.Z>=ShooterTile.Z && FarCover>0 && !`XWORLD.CanSeeTileToTile(ShooterTorso, TargetHead, VisibilityInfo)) NoLineOfSightMalus = -1000;
							NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (NextTile.Z>=ShooterTile.Z && FarCover>0 && !`XWORLD.CanSeeTileToTile(ShooterTorso, TargetHead, VisibilityInfo)) NoLineOfSightMalus = -1000; //LOW COVER IN CALCULATING VISIBILITY.
							NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (NextTile.Z>=ShooterTile.Z && FarCover>0 && !`XWORLD.CanSeeTileToTile(ShooterTorso, TargetHead, VisibilityInfo)) NoLineOfSightMalus = -1000; //THIS NONSENSE HAD TO BE MODDED AWAY...
						}
						if (ShooterHead.Z - TargetLegs.Z < 0) //ABOVE SHOOTER
						{
							NextTile = ShooterTile;
							NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (FarCover == 1 && !`XWORLD.CanSeeTileToTile(ShooterBelowFeet, TargetLegs, VisibilityInfo)) NoLineOfSightMalus = -1000; //DIFFERENT CHECK FOR HIGH GROUNDS
							NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (FarCover == 1 && !`XWORLD.CanSeeTileToTile(ShooterBelowFeet, TargetLegs, VisibilityInfo)) NoLineOfSightMalus = -1000; //IN CALCULATING VISIBILITY.
							NextTile = NextWalkableTile(ShooterTile, NextTile, TargetTile, FarCover); if (FarCover == 1 && !`XWORLD.CanSeeTileToTile(ShooterBelowFeet, TargetLegs, VisibilityInfo)) NoLineOfSightMalus = -1000;
						}
						If (NoLineOfSightMalus != 0) AddModifier(NoLineOfSightMalus, "No Line of Sight", m_ShotBreakdown, eHit_Success, bDebugLog);
					}

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 835 [2.20224]

B:BD[2.66768] → [2.66768:67963]

					if (default.AllowFarCoverToGiveSomeCoverProtection					 &&
						(TargetState.GetCurrentStat(eStat_AlertLevel)==`ALERT_LEVEL_RED || (TargetState.GetCurrentStat(eStat_AlertLevel)!=`ALERT_LEVEL_RED && !default.OnlyAlertedTargetsCanHaveTheExtraProtectionOfFarCoverAndHeightDisadvantage)) &&
						(VisInfo.TargetCover==CT_None || (GoodAngleBonus > 0 && ExtendedLowCoverPreventingGoodAngleBonus == 0)) && //FAR COVER ONLY IF NOT IN COVER OR IF THE COVER TAKEN IS NOT IN THE DIRECTION OF THE SHOOTER (MORE FLANKING THAN COVER)
						TileDistance > 2												 &&
						TargetState.GetMyTemplate().bCanTakeCover == true){
					//	ShooterTargetDistance = class'Helpers'.static.DistanceBetweenTiles(TargetTile, ShooterTile, false ); //FORGETTING THE "FALSE" VARIABLE WILL GIVE "SQUARED" DISTANCE!!!! MOTHERFUCKER!!! HOW GAVE SUCH A WRONG NAME TO
						ShooterTargetDistance =								 TilesDistance(TargetTile, ShooterTile		  ); //SUCH A DANGERIOUSLY MISLEADING FUNCTION!!!!??? HOWRS TRYING TO UNDERSTAND WHY DISTANCE WAS WRONGLY CALCULATED!!!
					//	ShooterTargetDistance =										 VSize(TargetLocation, ShooterLocation); // * 0.8; //NO FAR COVER 20% NEAR THE SHOOTER... NONSENSE.. ;)

[2.66768]

[2.67963]

					if (default.AllowFarCoverToGiveSomeCoverProtection && (TargetState.GetCurrentStat(eStat_AlertLevel)==`ALERT_LEVEL_RED || (TargetState.GetCurrentStat(eStat_AlertLevel)!=`ALERT_LEVEL_RED && !default.OnlyAlertedTargetsCanHaveTheExtraProtectionOfFarCoverAndHeightDisadvantage)) && (VisInfo.TargetCover==CT_None || (GoodAngleBonus > 0 && ExtendedLowCoverPreventingGoodAngleBonus == 0)) && //FAR COVER ONLY IF NOT IN COVER OR IF THE COVER TAKEN IS NOT IN THE DIRECTION OF THE SHOOTER (MORE FLANKING THAN COVER)
						TileDistance > 2 && TargetState.GetMyTemplate().bCanTakeCover == true)
					{
						ShooterTargetDistance = TilesDistance(TargetTile, ShooterTile); //SUCH A DANGERIOUSLY MISLEADING FUNCTION!!!!??? HOWRS TRYING TO UNDERSTAND WHY DISTANCE WAS WRONGLY CALCULATED!!!

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 840 [2.20224]

B:BD[2.67998] → [2.67998:68110]

						if (ShooterHeadRelativeElevation == 0){					NextTile = TargetTile;																	  FarCoverBonus =  0;

[2.67998]

[2.68110]

						if (ShooterHeadRelativeElevation == 0)
						{
							NextTile = TargetTile; FarCoverBonus =  0;
							if(FarCoverBonus==0 && NextTile.Z == TargetTile.Z) {NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover); if (FarCover>0) FarCoverBonus = 20 / (ShooterTargetDistance*0.7) * Max(0, TilesDistance(ShooterTile, NextTile) - ShooterTargetDistance*0.3);}

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 859 [2.20224]

B:BD[2.72250] → [2.72250:72619]

							if(FarCoverBonus==0 && NextTile.Z == TargetTile.Z) {NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover); if (FarCover>0) FarCoverBonus = 20 / (ShooterTargetDistance*0.7) * Max(0, TilesDistance(ShooterTile, NextTile) - ShooterTargetDistance*0.3);} }
						if (ShooterHead.Z - TargetLegs.Z < 0){					NextTile = TargetTile;	  //ABOVE SHOOTER

[2.72250]

[2.72619]

						}
						if (ShooterHead.Z - TargetLegs.Z < 0) //ABOVE SHOOTER
						{
							NextTile = TargetTile;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 868 [2.20224]

B:BD[2.73667] → [2.73667:73867]

							if(FarCoverBonus==0 && NextTile.Z == TargetTile.Z) {NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover); if (NextTile.Z>=TargetTile.Z && FarCover>0) FarCoverBonus = 20;}}

[2.73667]

[2.73867]

							if(FarCoverBonus==0 && NextTile.Z == TargetTile.Z) {NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover); if (NextTile.Z>=TargetTile.Z && FarCover>0) FarCoverBonus = 20;}
						}

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 871 [2.20224]

B:BD[2.74012] → [2.74012:74370]

						if (FarCoverBonus  > 0 && GoodAngleBonus > 0)					  {FarCoverBonus = Min(GoodAngleBonus, FarCoverBonus); FarCoverText = "FarCover Preventing GoodAngle";}
				//	AddModifier(	  -FarCoverBonus , FarCoverText, m_ShotBreakdown, eHit_Success, bDebugLog);}
					AddModifier(round(-FarCoverBonus), FarCoverText, m_ShotBreakdown, eHit_Success, bDebugLog);}

[2.74012]

[2.74370]

						if (FarCoverBonus  > 0 && GoodAngleBonus > 0) {FarCoverBonus = Min(GoodAngleBonus, FarCoverBonus); FarCoverText = "FarCover Preventing GoodAngle";}
						AddModifier(round(-FarCoverBonus), FarCoverText, m_ShotBreakdown, eHit_Success, bDebugLog);
					}

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 875 [2.20224]

B:BD[2.74372] → [2.74372:79476]

					if (default.ApplyVerticalBadAngleAgainstHigherTargetAsProportionalHeightDisadvantage &&
						ShooterHead.Z - TargetLegs.Z < 0												 && //TARGET STANDING ON A SURFACE HIGHER THAN THE SHOOTER'S HEAD
						(TargetState.GetCurrentStat(eStat_AlertLevel)==`ALERT_LEVEL_RED || (TargetState.GetCurrentStat(eStat_AlertLevel)!=`ALERT_LEVEL_RED && !default.OnlyAlertedTargetsCanHaveTheExtraProtectionOfFarCoverAndHeightDisadvantage)) &&
						TargetState.GetMyTemplate().bCanTakeCover == true							   //&& //HIGHER, LOWER OR SAME LEVEL, FAR COVER MUST GIVE SOME ADVANTAGE NO MATTER THE HEIGHT
					//	VisInfo.TargetCover == CT_None
																			){ //HEIGHT DISADVANTAGE DOESN'T INCREASE TARGET'S HIGH/LOW COVER... BUT ONLY ADDS FROM 1 TO 19 COVER WHEN BUILDING/CLIFF PARTIALLY ACTS AS LOW COVER
					//	Alpha = FClamp((VisInfo.TargetCoverAngle - MIN_ANGLE_TO_COVER																	 ) / (MAX_ANGLE_TO_COVER																	   - MIN_ANGLE_TO_COVER																	   ), 0.0, 1.0);
					//	Alpha = FClamp((VisInfo.TargetCoverAngle - 0																					 ) / (45																					   - 0																					   ), 0.0, 1.0);
						Alpha = FClamp((90-(-VerticalAngle)		 - 0																					 ) / (85																					   - 0																					   ), 0.0, 1.0);
					//	AngleToCoverModifier = Lerp(MAX_ANGLE_BONUS_MOD										  , MIN_ANGLE_BONUS_MOD										  , Alpha);
						AngleToCoverModifier = Lerp(1														  , 0														  , Alpha);
													//	 HeightDisadvantageMalus = round(VerticalAngle/90*(20)); //NEGATIVE RELATIVEELEVATION --> NEGATIVE VERTICALANGLE --> NEGATIVE MALUS//SOMETIMES YOU ARE SHOOTING FROM THE "SIDE OF HIS LOWCOVER" AND THE SIDE HAS ROOFCEILING AS PROTECTION...
														 HeightDisadvantageMalus = round(-AngleToCoverModifier*(20));						   NextTile = TargetTile;
				/*																															   NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);	//EACH "STEP BACKWARDS"//THE ROOFTOP-BORDER UNTIL
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}	//NEGATIVE RELATIVEELEVATION --> NEGATIVE VERTICALANGLE --> NEGATIVE MALUS
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);}
						if (NextTile.Z >= TargetTile.Z) {HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2);																		    }
				*/		if (VisInfo.TargetCover == CT_MidLevel) FarCover = 1;

[2.74372]

[2.79476]

					if (default.ApplyVerticalBadAngleAgainstHigherTargetAsProportionalHeightDisadvantage && ShooterHead.Z - TargetLegs.Z < 0 //TARGET STANDING ON A SURFACE HIGHER THAN THE SHOOTER'S HEAD
						&& (TargetState.GetCurrentStat(eStat_AlertLevel)==`ALERT_LEVEL_RED || (TargetState.GetCurrentStat(eStat_AlertLevel)!=`ALERT_LEVEL_RED && !default.OnlyAlertedTargetsCanHaveTheExtraProtectionOfFarCoverAndHeightDisadvantage)) && TargetState.GetMyTemplate().bCanTakeCover == true)							   //HIGHER, LOWER OR SAME LEVEL, FAR COVER MUST GIVE SOME ADVANTAGE NO MATTER THE HEIGHT
					{ //HEIGHT DISADVANTAGE DOESN'T INCREASE TARGET'S HIGH/LOW COVER... BUT ONLY ADDS FROM 1 TO 19 COVER WHEN BUILDING/CLIFF PARTIALLY ACTS AS LOW COVER
						Alpha = FClamp((90-(-VerticalAngle) - 0) / (85 - 0), 0.0, 1.0);
						AngleToCoverModifier = Lerp(1, 0, Alpha);
						HeightDisadvantageMalus = round(-AngleToCoverModifier*(20)); NextTile = TargetTile;
						if (VisInfo.TargetCover == CT_MidLevel) FarCover = 1;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 885 [2.20224]

B:BD[2.79675] → [2.79675:79937]

							//	HeightDisadvantageMalus = round(HeightDisadvantageMalus + HeightDisadvantageMalus/2); //ROUNDING SMALL PERCENTAGES NEVER
								HeightDisadvantageMalus =		HeightDisadvantageMalus + HeightDisadvantageMalus/2 ; //GIVES LARGE SUMS! ROUND AT THE END!!!

[2.79675]

[2.79937]

								HeightDisadvantageMalus = HeightDisadvantageMalus + HeightDisadvantageMalus/2 ; //GIVES LARGE SUMS! ROUND AT THE END!!!

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 887 [2.20224]

B:BD[2.79947] → [2.79947:80287]

					//		     HeightDisadvantageMalus =		  HeightDisadvantageMalus/(TargetState.UnitHeight-1); // TALL FACELESS/SECTOPODS DON'T HIDE MUCH BEHIND HIGH BUILDINGS/CLIFFS BORDERS
					//		 if (HeightDisadvantageMalus < -1000) HeightDisadvantageMalus = -1000;
					//	else if (HeightDisadvantageMalus <	 -20) HeightDisadvantageMalus =	  -20;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 888 [2.20224]

B:BD[2.80366] → [2.80366:80707]

					//	AddModifier(	  HeightDisadvantageMalus , class'XLocalizedData'.default.HeightDisadvantage, m_ShotBreakdown, eHit_Success, bDebugLog);} //POSITIVE OR NEGATIVE???
						AddModifier(round(HeightDisadvantageMalus), class'XLocalizedData'.default.HeightDisadvantage, m_ShotBreakdown, eHit_Success, bDebugLog);} //POSITIVE OR NEGATIVE???

[2.80366]

[2.80707]

						AddModifier(round(HeightDisadvantageMalus),
						class'XLocalizedData'.default.HeightDisadvantage, m_ShotBreakdown,
						eHit_Success, bDebugLog); //POSITIVE OR NEGATIVE???
					}

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 960 [2.20224]
B:BD[2.82975] → [2.82975:83142]
```
		//	PersistentEffect.GetToHitModifiers(EffectState, UnitState, TargetState, kAbility, self.Class						   , bMeleeAttack, bFlanking, bIndirectFire, EffectModifiers);
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 999 [2.20224]

B:BD[2.84473] → [2.84473:84847]

			//	PersistentEffect.GetToHitAsTargetModifiers(EffectState, UnitState, TargetState, kAbility									   , self.Class, bMeleeAttack, bFlanking, bIndirectFire, EffectModifiers);
				PersistentEffect.GetToHitAsTargetModifiers(EffectState, UnitState, TargetState, kAbility, class'X2AbilitytoHitCalc_StandardAim',			 bMeleeAttack, bFlanking, bIndirectFire, EffectModifiers);

[2.84473]

[2.84847]

				PersistentEffect.GetToHitAsTargetModifiers(EffectState, UnitState, TargetState, kAbility, class'X2AbilitytoHitCalc_StandardAim', bMeleeAttack, bFlanking, bIndirectFire, EffectModifiers);

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1045 [2.20224]

B:BD[2.86531] → [2.86531:86878]

function TTile NextWalkableTile(	TTile OriginTile	 ,	//		  Y
									TTile MidTile		 ,	//		  ^
									TTile DestinationTile,	//		  |
								out int	  FarCover		 ){ //  X <--
	local TTile    TileDifference;
	local TTile    NextTile;
	local int	   Direction;
	local int	   OriginDestinationAngle;
	local int	   MidTileDestinationAngle;

[2.86531]

[2.86878]

function TTile NextWalkableTile(
	TTile OriginTile,	//	  Y
	TTile MidTile,		//	  ^
	TTile DestinationTile,	//	  |
	out int FarCover)	//  X <--
{
	local TTile TileDifference;
	local TTile NextTile;
	local int Direction;
	local int OriginDestinationAngle;
	local int MidTileDestinationAngle;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1059 [2.20224]

B:BD[2.87018] → [2.87018:87121]

	MidTileDestinationAngle = Abs(DestinationTile.X - MidTile	.X) / Abs(DestinationTile.Y - MidTile	.Y);

[2.87018]

[2.87121]

	MidTileDestinationAngle = Abs(DestinationTile.X - MidTile.X) / Abs(DestinationTile.Y - MidTile.Y);

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1067 [2.20224]

B:BD[2.87284] → [2.87284:87502]

//	if (Abs(TileDifference.X) >  Abs(TileDifference.Y) && OriginDestinationAngle >= MidTileDestinationAngle ||
//		Abs(TileDifference.X) <= Abs(TileDifference.Y) && OriginDestinationAngle < MidTileDestinationAngle ){

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1070 [2.20224]

B:BD[2.87651] → [2.87651:87869]

//	if (Abs(TileDifference.X) <= Abs(TileDifference.Y) && OriginDestinationAngle >= MidTileDestinationAngle ||
//		Abs(TileDifference.X) >  Abs(TileDifference.Y) && OriginDestinationAngle < MidTileDestinationAngle ){

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1088 [2.20224]
B:BD[2.88570] → [2.88570:88712]
```
//	arrEnemyInfos[EnemyInfoIndex].TargetCover = World.GetCoverTypeForTarget(vEnemyPos, vLoc, arrEnemyInfos[EnemyInfoIndex].TargetCoverAngle);
```

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1095 [2.20224]

B:BD[2.88997] → [2.88997:89655]

/*	if( (Abs(TileDifference.X) >  Abs(TileDifference.Y) && TargetCoverAngle>45) || //FROM FRONT OF X-AXIS COVER
		(Abs(TileDifference.X) >  Abs(TileDifference.Y) && TargetCoverAngle<45) ){ //FROM SIDE  OF X-AXIS COVER
		if( TileDifference.X > 0) {TileAboveCover.X += 1;}
		if( TileDifference.X <=0) {TileAboveCover.X -= 1;}}
	if( (Abs(TileDifference.X) <= Abs(TileDifference.Y) && TargetCoverAngle>45) || //FROM FRONT OF Y-AXIS COVER
		(Abs(TileDifference.X) <= Abs(TileDifference.Y) && TargetCoverAngle<45) ){ //FROM SIDE  OF Y-AXIS COVER
		if( TileDifference.Y > 0) {TileAboveCover.Y += 1;}
		if( TileDifference.Y <=0) {TileAboveCover.Y -= 1;}}
*/

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1097 [2.20224]

B:BD[2.89786] → [2.89786:89907]

	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) ||
	   `XWORLD.IsTileOccupied	  (TileAboveCover)	) return CT_Standing;

[2.89786]

[2.89907]

	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) || `XWORLD.IsTileOccupied(TileAboveCover)) return CT_Standing;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1101 [2.20224]

B:BD[2.90040] → [2.90040:90953]

	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) ||
	   `XWORLD.IsTileOccupied	  (TileAboveCover)	) return CT_Standing;
/*
	TileAboveCover = DestTile; TileAboveCover.Z += 1; TileAboveCover.X += 1;
	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) ||
	   `XWORLD.IsTileOccupied	  (TileAboveCover)	) return CT_Standing;
	TileAboveCover = DestTile; TileAboveCover.Z += 1; TileAboveCover.X -= 1;
	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) ||
	   `XWORLD.IsTileOccupied	  (TileAboveCover)	) return CT_Standing;
	TileAboveCover = DestTile; TileAboveCover.Z += 1; TileAboveCover.Y += 1;
	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) ||
	   `XWORLD.IsTileOccupied	  (TileAboveCover)	) return CT_Standing;
	TileAboveCover = DestTile; TileAboveCover.Z += 1; TileAboveCover.Y -= 1;
	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) ||
	   `XWORLD.IsTileOccupied	  (TileAboveCover)	) return CT_Standing;
*/

[2.90040]

[2.90953]

	if(`XWORLD.IsTileFullyOccupied(TileAboveCover) || `XWORLD.IsTileOccupied(TileAboveCover)) return CT_Standing;

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1103 [2.20224]
B:BD[2.90956] → [2.90956:90960]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1105 [2.20224]

B:BD[2.90964] → [2.90964:91132]

function bool CoverOnBothSides(	TTile ShooterTile,
								TTile TargetTile) {
	local TTile    TileDifference;
	local int	   DirectionX;
	local int	   DirectionY;

[2.90964]

[2.91132]

function bool CoverOnBothSides(TTile ShooterTile, TTile TargetTile)
{
	local TTile TileDifference;
	local int DirectionX;
	local int DirectionY;

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1126 [2.20224]
B:BD[2.91789] → [2.91789:91857]
```
		(TargetTileData.CoverFlags & DirectionY) != 0  ) return true;}
```
[2.91789]
[2.91857]
```
		(TargetTileData.CoverFlags & DirectionY) != 0) return true;
}
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1130 [2.20224]
B:BD[2.91861] → [2.91861:91863]

remove commented code and excess tabs

Dependencies

In channels

Change contents

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1 [2.20224]

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 7 [2.20224]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 28 [2.20224]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 30 [2.20224]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 35 [2.20224]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 44 [2.20224]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 61 [2.20224]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 67 [2.20224]

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 95 [2.20224]

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 107 [2.20224]

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 321 [2.20224]

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 322 [2.20224]