rohan/XCom2-RWRealisticAimingAnglesHL - Change 6GNTEDE4K6MYWCBF7YXRRJ6MD66QOTVW74QWNGBYJMNN37ABZJWAC

use real LOS functions to determine Far Cover (automatically accounts for roof edge protection)

NextWalkableTile is not at all reliable with edges

Created by rohan on September 10, 2022

6GNTEDE4K6MYWCBF7YXRRJ6MD66QOTVW74QWNGBYJMNN37ABZJWAC

Dependencies

In channels

main

Change contents

File move: Override_X2AbilityToHitCalc_StandardAim.uc (---x------) → Override_X2AbilityToHitCalc_StandardAim.uc (----------)
BF:BFD[5.1208] → [5.92147:92213]
BF:BF[5.92213] → [5.20224:20224]
[5.1208]
[5.20224]
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 42 [5.20224]
B:BD[5.22843] → [5.22843:22845]
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 587 [5.20224]
B:BD[6.1248] → [6.1248:1371]
```
	local TTile ShooterTorso;
	local TTile TargetLegs;
	local TTile ShooterBelowFeet;
	local float ShooterTargetDistance;
```
Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 590 [5.20224]
B:BD[6.1474] → [6.1474:1530]
```
	local float ExtendedLowCoverPreventingGoodAngleBonus;
```

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 591 [5.20224]

B:BD[6.1603] → [6.1603:1882]

∅:D[6.1882] → [5.46120:46174]

B:BD[5.46120] → [5.46120:46174]

	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;
	local GameRulesCache_VisibilityInfo VisibilityInfo;

Insertion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 592 [5.20224]
[6.1930]
[5.46356]
```
        local TTile PeekTile, PeekHead, LosTile, TargetPeekTile;
	local VoxelRaytraceCheckResult RayTrace;
	local int FarCover;
```

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 792 [5.20224]

B:BD[6.3509] → [6.3509:3697]

B:BD[6.3697] → [3.74:200]

∅:D[3.200] → [6.3697:3964]

B:BD[6.3697] → [6.3697:3964]

									if ((NextTileOverCoverType == CT_MidLevel || NextTileOverCoverType == CT_Standing))
									{
										ExtendedLowCoverPreventingGoodAngleBonus = -Round(GoodAngleBonus / 2);
										`log("ExtendedLowCoverPreventingGoodAngleBonus:"@ExtendedLowCoverPreventingGoodAngleBonus, true, 'XCom_HitRolls');
										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 808 [5.20224]
B:BD[5.61632] → [5.61632:61634]

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 811 [5.20224]

B:BD[5.61710] → [6.3965:4244]

∅:D[6.4244] → [5.62411:62474]

B:BD[5.62411] → [5.62411:62474]

B:BD[5.62474] → [6.4245:4276]

					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;
					ShooterBelowFeet = ShooterTile; ShooterBelowFeet.Z -= 2;
					TargetLegs = TargetTile;

[5.61710]

[5.62507]

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

Insertion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 829 [5.20224]

[6.5172]

[5.64789]


					if (default.AllowFarCoverToGiveSomeCoverProtection || default.GiveHitChanceZeroWhenTargetableEnemiesAreInsteadNotTrulyInLineOfSight)
					{
						// Both these modifiers are based off far cover
						FarCover = 0;
						PeekTile = VisInfo.SourceTile;
						PeekHead = PeekTile; PeekHead.Z = `XWORLD.GetFloorTileZ(PeekTile) + UnitState.UnitHeight;
						`log("PeekTile:"@PeekTile.X@","@PeekTile.Y@","@PeekTile.Z, true, 'XCom_HitRolls');
						`log("PeekHead:"@PeekHead.X@","@PeekHead.Y@","@PeekHead.Z, true, 'XCom_HitRolls');
						TargetPeekTile = VisInfo.DestTile;
						`log("TargetTile:"@TargetTile.X@","@TargetTile.Y@","@TargetTile.Z, true, 'XCom_HitRolls');
						`log("TargetPeekTile:"@TargetPeekTile.X@","@TargetPeekTile.Y@","@TargetPeekTile.Z, true, 'XCom_HitRolls');
						`log("Target Height:"@TargetState.UnitHeight, true, 'XCom_HitRolls');

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 845 [5.20224]

B:BD[5.64791] → [6.5173:6985]

B:BD[6.6985] → [3.284:362]

∅:D[3.362] → [6.6985:7116]

B:BD[6.6985] → [6.6985:7116]

B:BD[6.7116] → [6.7116:7124]

					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;
						}
						`log("NoLineOfSightMalus:"@NoLineOfSightMalus, true, 'XCom_HitRolls');
						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 846 [5.20224]

B:BD[5.66768] → [4.72:621]

∅:D[4.621] → [6.7636:7714]

B:BD[6.7636] → [6.7636:7714]

B:BD[6.7714] → [6.7714:7722]

B:BD[6.7722] → [6.7722:7908]

∅:D[6.7908] → [5.67963:67998]

B:BD[5.67963] → [5.67963:67998]

B:BD[5.67998] → [6.7909:7955]

					if (default.AllowFarCoverToGiveSomeCoverProtection && (TargetState.GetTeam() == eTeam_XCom || 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!!!
						FarCoverText = "Far Cover";
						if (ShooterHeadRelativeElevation == 0)

[5.66768]

[6.7955]

						// FarCover to a tile which may already be granting cover
						LosTile = TargetTile;
						LosTile.Z = `XWORLD.GetFloorTileZ(TargetTile);
						for (i=0; i<=TargetState.UnitHeight; i++)

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 851 [5.20224]

B:BD[6.7964] → [6.7964:8015]

B:BD[6.8015] → [3.363:446]

							NextTile = TargetTile; FarCoverBonus =  0;
							for (i = 0; i < 16 && FarCoverBonus==0 && NextTile.Z == TargetTile.Z; ++i)

[6.7964]

[3.446]

							if (`XWORLD.VoxelRaytrace_Tiles(PeekTile, LosTile, RayTrace))

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 853 [5.20224]

B:BD[3.456] → [3.456:564]

								NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover);
								if (FarCover>0)

[3.456]

[3.564]

								if ((i == 0 && VisInfo.TargetCover == CT_None) || ((i == 1 || i == 2) && VisInfo.TargetCover != CT_Standing) || i > 2)

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 855 [5.20224]

B:BD[3.575] → [3.575:723]

									FarCoverBonus = LOW_COVER_BONUS / (ShooterTargetDistance*0.7) * Max(0, TilesDistance(ShooterTile, NextTile) - ShooterTargetDistance*0.3);

[3.575]

[3.723]

									`log("LOS blocked by far cover:"@i@","@VisInfo.TargetCover, true, 'XCom_HitRolls');
									FarCover += 1;

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

∅:D[3.744] → [6.8292:8402]

B:BD[5.72250] → [6.8292:8402]

B:BD[6.8402] → [3.745:827]

						}
						if (ShooterHead.Z - TargetLegs.Z < 0) //ABOVE SHOOTER
						{
							NextTile = TargetTile;
							for (i = 0; i < 5 && FarCoverBonus==0 && NextTile.Z == TargetTile.Z; ++i)

[3.744]

[3.827]


							if (`XWORLD.VoxelRaytrace_Tiles(PeekHead, LosTile, RayTrace))

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 862 [5.20224]

B:BD[3.837] → [3.837:973]

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

[3.837]

[3.973]

								if ((i == 0 && VisInfo.TargetCover == CT_None) || ((i == 1 || i == 2) && VisInfo.TargetCover != CT_Standing) || i > 2)

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 864 [5.20224]

B:BD[3.984] → [3.984:1079]

									FarCoverBonus = LOW_COVER_BONUS;  //DIFFERENT VALUE FOR FAR COVER ON ELEVATED GROUND

[3.984]

[3.1079]

									`log("LOS blocked by far cover:"@i@","@VisInfo.TargetCover, true, 'XCom_HitRolls');
									FarCover += 1;

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 868 [5.20224]
∅:D[3.1100] → [6.8602:8611]
B:BD[6.8602] → [6.8602:8611]
∅:D[6.8611] → [5.73867:74012]
B:BD[5.73867] → [5.73867:74012]
```
						}
						if (TilesDistance(TargetTile, NextTile) >= ShooterTargetDistance) {FarCoverBonus =  0;} //DON'T CONSIDER FAR COVER "BEHIND" SHOOTER... ;)
```

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 869 [5.20224]

∅:D[2.1192] → [6.8612:8767]

B:BD[5.74012] → [6.8612:8767]

B:BD[6.8767] → [3.1101:1177]

∅:D[3.1177] → [6.8767:8874]

B:BD[6.8767] → [6.8767:8874]

						if (FarCoverBonus  > 0 && GoodAngleBonus > 0) {FarCoverBonus = Min(GoodAngleBonus, FarCoverBonus); FarCoverText = "FarCover Preventing GoodAngle";}
						`log("FarCoverBonus:"@round(-FarCoverBonus), true, 'XCom_HitRolls');
						AddModifier(round(-FarCoverBonus), FarCoverText, m_ShotBreakdown, eHit_Success, bDebugLog);
					}

[2.1192]

[5.74370]

							LosTile.Z++;
						}

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 872 [5.20224]

B:BD[5.74372] → [6.8875:9064]

B:BD[6.9064] → [4.622:1040]

∅:D[4.1040] → [6.9444:9871]

B:BD[6.9444] → [6.9444:9871]

B:BD[6.9871] → [2.1193:1240]

					if (default.ApplyVerticalBadAngleAgainstHigherTargetAsProportionalHeightDisadvantage && ShooterHead.Z - TargetLegs.Z < 0 //TARGET STANDING ON A SURFACE HIGHER THAN THE SHOOTER'S HEAD
						&& (TargetState.GetTeam() == eTeam_XCom || 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;
						if (VisInfo.TargetCover != CT_MidLevel)

[5.74372]

[2.1240]

						// FarCover for which cover hasn't been determined already
						LosTile = TargetPeekTile;
						LosTile.Z = `XWORLD.GetFloorTileZ(TargetTile);
						for (i=0; i<=TargetState.UnitHeight; i++)

Replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 877 [5.20224]

B:BD[2.1249] → [2.1249:1277]

							for (i=1;i==20;++i)

[2.1249]

[2.1277]

							if (`XWORLD.VoxelRaytrace_Tiles(PeekTile, LosTile, RayTrace))
							{
								`log("LOS blocked by far cover:"@i, true, 'XCom_HitRolls');
								FarCover += 1;
							}
							if (`XWORLD.VoxelRaytrace_Tiles(PeekHead, LosTile, RayTrace))

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

∅:D[2.1287] → [5.79554:79675]

B:BD[5.79554] → [5.79554:79675]

B:BD[5.79675] → [6.9872:10001]

								NextTile = NextWalkableTile(TargetTile, NextTile, ShooterTile, FarCover); if (NextTile.Z < TargetTile.Z) break;
								HeightDisadvantageMalus = HeightDisadvantageMalus + HeightDisadvantageMalus/2 ; //GIVES LARGE SUMS! ROUND AT THE END!!!

[2.1287]

[2.1288]

								`log("LOS blocked by far cover:"@i, true, 'XCom_HitRolls');
								FarCover += 1;

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

B:BD[2.1298] → [2.1298:1349]

∅:D[2.1349] → [5.80287:80366]

B:BD[5.80287] → [5.80287:80366]

B:BD[5.80366] → [6.10002:10186]

                                                }
						if (FarCover==1) HeightDisadvantageMalus = 2 * HeightDisadvantageMalus;
						AddModifier(round(HeightDisadvantageMalus),
						class'XLocalizedData'.default.HeightDisadvantage, m_ShotBreakdown,
						eHit_Success, bDebugLog); //POSITIVE OR NEGATIVE???

[2.1298]

[6.10186]


							LosTile.Z++;
						}
						// Big things are easy to hit even if partially covered
						if (TargetState.UnitHeight > 2)
						{
							FarCover = Max(0, FarCover - (TargetState.UnitHeight - 2) * 2);
						}
						if (default.GiveHitChanceZeroWhenTargetableEnemiesAreInsteadNotTrulyInLineOfSight && FarCover == 12)
						{
							`log("NoLineOfSightMalus: -1000", true, 'XCom_HitRolls');
							AddModifier(-1000, "No Line of Sight", m_ShotBreakdown, eHit_Success, bDebugLog);
						}
						else if (default.AllowFarCoverToGiveSomeCoverProtection && (TargetState.GetTeam() == eTeam_XCom || TargetState.GetCurrentStat(eStat_AlertLevel)==`ALERT_LEVEL_RED || (TargetState.GetCurrentStat(eStat_AlertLevel)!=`ALERT_LEVEL_RED && !default.OnlyAlertedTargetsCanHaveTheExtraProtectionOfFarCoverAndHeightDisadvantage)))
						{
							// Scale far cover to high cover
							FarCoverBonus = FarCover * HIGH_COVER_BONUS / 12; // 12 is the maximum considered ray
							`log("FarCoverBonus:"@round(-FarCoverBonus), true, 'XCom_HitRolls');
							AddModifier(round(-FarCoverBonus), "Far Cover", m_ShotBreakdown, eHit_Success, bDebugLog);
						}

Deletion in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1097 [5.20224]

B:BD[5.90960] → [5.90960:90964]

B:BD[5.90964] → [6.11018:11168]

∅:D[6.11168] → [5.91132:91789]

B:BD[5.91132] → [5.91132:91789]

B:BD[5.91789] → [6.11169:11235]

∅:D[6.11235] → [5.91857:91859]

B:BD[5.91857] → [5.91857:91859]

B:BD[5.91859] → [5.91859:91861]

B:BD[5.91863] → [5.91863:92146]

B:BD[5.86531] → [6.10388:10689]

∅:D[6.10689] → [5.86878:87018]

B:BD[5.86878] → [5.86878:87018]

B:BD[5.87018] → [6.10690:10791]

∅:D[6.10791] → [5.87121:87284]

B:BD[5.87121] → [5.87121:87284]

B:BD[5.87502] → [5.87502:87651]

B:BD[5.87869] → [5.87869:88570]


function bool CoverOnBothSides(TTile ShooterTile, TTile TargetTile)
{
	local TTile TileDifference;
	local int DirectionX;
	local int DirectionY;
	local TileData TargetTileData;
	TileDifference.X = TargetTile.X - ShooterTile.X;
	TileDifference.Y = TargetTile.Y - ShooterTile.Y;
	DirectionX = 0;
	DirectionY = 0;
	if( Abs(TileDifference.X) >  Abs(TileDifference.Y) ) {
		if( TileDifference.X > 0) {DirectionX = `XWORLD.COVER_West;}
		if( TileDifference.X <=0) {DirectionX = `XWORLD.COVER_East;}}
	if( Abs(TileDifference.X) <= Abs(TileDifference.Y) ) {
		if( TileDifference.Y > 0) {DirectionY = `XWORLD.COVER_North;}
		if( TileDifference.Y <=0) {DirectionY = `XWORLD.COVER_South;}}
	`XWORLD.GetTileData(TargetTile, TargetTileData);
	if ((TargetTileData.CoverFlags & DirectionX) != 0 &&
		(TargetTileData.CoverFlags & DirectionY) != 0) return true;
}
static function float TilesDistance(TTile TileA, TTile TileB)
{
	local XComWorldData World;
	local vector LocA, LocB;
	World = `XWORLD;
	LocA = World.GetPositionFromTileCoordinates(TileA);
	LocB = World.GetPositionFromTileCoordinates(TileB);
	return VSize(LocA - LocB);
}
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;
	local TileData NextTileData;
	OriginDestinationAngle  = Abs(DestinationTile.X - OriginTile.X) / Abs(DestinationTile.Y - OriginTile.Y);
	MidTileDestinationAngle = Abs(DestinationTile.X - MidTile.X) / Abs(DestinationTile.Y - MidTile.Y);
	NextTile = MidTile;
	TileDifference.X = DestinationTile.X - MidTile.X;
	TileDifference.Y = DestinationTile.Y - MidTile.Y;
	Direction = 0;
	FarCover = 0;
	if (OriginDestinationAngle <= MidTileDestinationAngle){
		if( TileDifference.X > 0) {++NextTile.X;}
		if( TileDifference.X <=0) {--NextTile.X;}}
	if (OriginDestinationAngle > MidTileDestinationAngle){
		if( TileDifference.Y > 0) {++NextTile.Y;}
		if( TileDifference.Y <=0) {--NextTile.Y;}}
	if (Abs(TileDifference.X) >  Abs(TileDifference.Y)){
		if( TileDifference.X > 0) {Direction = `XWORLD.COVER_WLow;}
		if( TileDifference.X <=0) {Direction = `XWORLD.COVER_ELow;}}
	if (Abs(TileDifference.X) <= Abs(TileDifference.Y)){
		if( TileDifference.Y > 0) {Direction = `XWORLD.COVER_NLow;}
		if( TileDifference.Y <=0) {Direction = `XWORLD.COVER_SLow;}}
	NextTile.Z = `XWORLD.GetFloorTileZ(NextTile);
	`XWORLD.GetTileData(NextTile, NextTileData);
	if ((NextTileData.CoverFlags & Direction) != 0) FarCover = 1;
	return NextTile;}

Solving an order conflict in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1097 [5.20224]
[5.90956]