remove commented code and excess tabs

rohan

Aug 28, 2022, 4:37 AM

JSCVVDFDJPB44MYIIERF62A6R7G5I5NDGLXFTL43TP6T4OFREQHAC

Dependencies

• [2] X4IR7ZAH baseline from krumiro's [WotC] RW Realistic Aiming Angles

Change contents

• replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1
  [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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 7
  [2.20755]→[2.20755:20907](∅→∅),[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.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.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.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.22847]→[2.22847:22849](∅→∅),[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.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.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;
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 95
  [2.25135]→[2.25135:25222](∅→∅)
  − // if( !`CHEATMGR.bXComOnlyDeadEye || !UnitState.ControllingPlayerIsAI() )
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 107
  [2.25633]→[2.25633:25717](∅→∅)
  − // RandRoll = `SYNC_RAND_TYPED(100, ESyncRandType_Generic);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 321
  [2.34998]→[2.34998:35112](∅→∅)
  − // UnitState = XComGameState_Unit(History.GetGameStateForObjectID(kAbility.OwnerStateObject.ObjectID));
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 322
  [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.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.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.46174]→[2.46174:46356](∅→∅)
  − // local XComGameState NewGameStateForDestructibleObject;

  − // local XComGameState_Destructible TargetStateDestructibleObject;

  − local ECoverType CoverTypeOfTileAboveTarget;
  [2.46174]

  [2.46356]
  + local ECoverType CoverTypeOfTileAboveTarget;
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 603
  [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.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.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.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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 740
  [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.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.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.56420]→[2.56420:56536](∅→∅),[2.56536]→[2.56536:56538](∅→∅),[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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 753
  [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.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.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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 768
  [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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 769
  [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.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... ;)
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 781
  [2.60587]→[2.60587:60675](∅→∅)
  − // if (UnitState.HasHeightAdvantageOver(TargetState, true) )
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 787
  [2.61057]→[2.61057:61146](∅→∅)
  − // if (TargetState.HasHeightAdvantageOver(UnitState, false) )
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 790
  [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.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.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.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.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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 812
  [2.64425]→[2.64425:64512](∅→∅)
  − // AngleToCoverModifier = Lerp(1 , 0 , Alpha);
• replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 813
  [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.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.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.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.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.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.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.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.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!!!
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 887
  [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.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???

  + }
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 960
  [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.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.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.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);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1067
  [2.87284]→[2.87284:87502](∅→∅)
  − // if (Abs(TileDifference.X) > Abs(TileDifference.Y) && OriginDestinationAngle >= MidTileDestinationAngle ||

  − // Abs(TileDifference.X) <= Abs(TileDifference.Y) && OriginDestinationAngle < MidTileDestinationAngle ){
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1070
  [2.87651]→[2.87651:87869](∅→∅)
  − // if (Abs(TileDifference.X) <= Abs(TileDifference.Y) && OriginDestinationAngle >= MidTileDestinationAngle ||

  − // Abs(TileDifference.X) > Abs(TileDifference.Y) && OriginDestinationAngle < MidTileDestinationAngle ){
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1088
  [2.88570]→[2.88570:88712](∅→∅)
  − // arrEnemyInfos[EnemyInfoIndex].TargetCover = World.GetCoverTypeForTarget(vEnemyPos, vLoc, arrEnemyInfos[EnemyInfoIndex].TargetCoverAngle);
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1095
  [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.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.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;
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1103
  [2.90956]→[2.90956:90960](∅→∅)
  −

  −
• replacement in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1105
  [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.91789]→[2.91789:91857](∅→∅)
  − (TargetTileData.CoverFlags & DirectionY) != 0 ) return true;}

  −
  [2.91789]

  [2.91857]
  + (TargetTileData.CoverFlags & DirectionY) != 0) return true;

  + }
• edit in RWRealisticAimingAnglesHL/Src/RWRealisticAimingAnglesHL/Classes/Override_X2AbilityToHitCalc_StandardAim.uc at line 1130
  [2.91861]→[2.91861:91863](∅→∅)
  −