private static void Postfix(ToHit __instance, ref string __result, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
if (attacker.HasMovedThisRound && attacker.JumpedLastRound)
{
__result = string.Format("{0}JUMPED {1:+#;-#}; ", __result, CBTMovement.Settings.ToHitSelfJumped);
}
}
static void Postfix(ToHit __instance, ref float __result, Mech attacker, ICombatant target, Vector3 targetPosition, MeleeAttackType meleeAttackType)
{
Mod.Log.Trace?.Write("TH:GAMM entered");
if (__instance == null)
{
return;
}
MeleeAttack selectedAttack = ModState.GetSelectedAttack(attacker);
if (selectedAttack == null)
{
return;
}
Mod.Log.Debug?.Write("Adding CBTBE modifiers to ToHit");
int sumMod = 0;
foreach (KeyValuePair <string, int> kvp in selectedAttack.AttackModifiers)
{
string localText = new Text(Mod.LocalizedText.Labels[kvp.Key]).ToString();
Mod.Log.Debug?.Write($" - Found attack modifier: {localText} = {kvp.Value}, adding to sum modifier");
sumMod += kvp.Value;
}
__result += (float)sumMod;
}
private static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
if (attacker.HasMovedThisRound && attacker.JumpedLastRound)
{
__result = __result + (float)CBTMovement.Settings.ToHitSelfJumped;
}
}
private static void Postfix(ToHit __instance, ref string __result, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
Pilot pilot = attacker.GetPilot();
if (pilot.pilotDef.PilotTags.Contains("pilot_reckless"))
{
__result = string.Format("{0}RECKLESS {1:+#;-#}; ", __result, settings.pilot_reckless_ToHitBonus);
}
if (pilot.pilotDef.PilotTags.Contains("pilot_cautious"))
{
__result = string.Format("{0}CAUTIOUS {1:+#;-#}; ", __result, settings.pilot_cautious_ToHitBonus);
}
if (pilot.pilotDef.PilotTags.Contains("pilot_drunk") && pilot.pilotDef.TimeoutRemaining > 0)
{
__result = string.Format("{0}DRUNK {1:+#;-#}; ", __result, settings.pilot_drunk_ToHitBonus);
}
if (pilot.pilotDef.PilotTags.Contains("pilot_lostech") && weapon.componentDef.ComponentTags.Contains("component_type_lostech"))
{
__result = string.Format("{0}LOSTECH TECHNICIAN {1:+#;-#}; ", __result, settings.pilot_lostech_ToHitBonus);
}
if (pilot.pilotDef.PilotTags.Contains("pilot_jinxed"))
{
__result = string.Format("{0}JINXED {1:+#;-#}; ", __result, settings.pilot_reckless_ToHitBonus);
}
}
static void Postfix(ToHit __instance, ref string __result, AbstractActor attacker, Weapon weapon, ICombatant target,
Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
Mod.Log.Trace?.Write("TH:GAMD entered");
if (attacker.HasMovedThisRound && attacker.JumpedLastRound ||
(SharedState.CombatHUD?.SelectionHandler?.ActiveState != null &&
SharedState.CombatHUD?.SelectionHandler?.ActiveState is SelectionStateJump))
{
string localText = new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Attacker_Jumped]).ToString();
__result = string.Format("{0}{1} {2:+#;-#}; ", __result, localText, Mod.Config.ToHitSelfJumped);
}
// Check melee patches
MeleeAttack selectedAttack = ModState.GetSelectedAttack(attacker);
if (selectedAttack != null && weapon.Type == WeaponType.Melee)
{
foreach (KeyValuePair <string, int> kvp in selectedAttack.AttackModifiers)
{
string localText = new Text(Mod.LocalizedText.Labels[kvp.Key]).ToString();
Mod.Log.Info?.Write($" - Found attack modifier for desc: {localText} = {kvp.Value}");
__result = string.Format("{0}{1} {2:+#;-#}; ", __result, localText, kvp.Value);
}
}
}
public static void Postfix(ToHit __instance, ref string __result, CombatGameState ___combat, AbstractActor attacker, Weapon weapon, ICombatant target)
{
try
{
if (DemandingJumps.Settings.ToHitSelfJumpedSpareAI && !___combat.LocalPlayerTeam.IsActive)
{
return;
}
Logger.Info("[ToHit_GetAllModifiersDescription_POSTFIX] CombatGameState.LocalPlayerTeam.IsActive: " + ___combat.LocalPlayerTeam.IsActive);
bool AttackerJumpedThisRound = attacker.HasMovedThisRound && attacker.JumpedLastRound;
Logger.Info("[ToHit_GetAllModifiersDescription_POSTFIX] Fields.JumpPreview: " + Fields.JumpPreview);
Logger.Info("[ToHit_GetAllModifiersDescription_POSTFIX] AttackerJumpedThisRound: " + AttackerJumpedThisRound);
if (AttackerJumpedThisRound)
{
int ToHitSelfJumpedModifier = Utilities.GetAttackerJumpedAccuracyModifier(attacker);
Logger.Debug("[ToHit_GetAllModifiersDescription_POSTFIX] Add description for ToHitSelfJumped: " + ToHitSelfJumpedModifier);
__result = string.Format("{0}JUMPED {1:+#;-#}; ", __result, ToHitSelfJumpedModifier);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void Postfix(ToHit __instance, ref float __result, CombatGameState ___combat, AbstractActor attacker, Weapon weapon, ICombatant target)
{
try
{
if (DemandingJumps.Settings.ToHitSelfJumpedSpareAI && !___combat.LocalPlayerTeam.IsActive)
{
return;
}
Logger.Info("[ToHit_GetAllModifiers_POSTFIX] CombatGameState.LocalPlayerTeam.IsActive: " + ___combat.LocalPlayerTeam.IsActive);
bool AttackerJumpedThisRound = attacker.HasMovedThisRound && attacker.JumpedLastRound;
Logger.Info("[ToHit_GetAllModifiers_POSTFIX] Fields.JumpPreview: " + Fields.JumpPreview);
Logger.Info("[ToHit_GetAllModifiers_POSTFIX] AttackerJumpedThisRound: " + AttackerJumpedThisRound);
if (Fields.JumpPreview || AttackerJumpedThisRound)
{
int ToHitSelfJumpedModifier = Utilities.GetAttackerJumpedAccuracyModifier(attacker);
Logger.Info("[ToHit_GetAllModifiers_POSTFIX] Unit previews jump or already jumped. Applying ToHit penalty.");
__result = __result + (float)ToHitSelfJumpedModifier;
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
List <ListViewItem> IWeaponModifier.ToListViewItems()
{
var collection = new List <ListViewItem>();
var toHit = new ListViewItem(new [] { "ToHit", ToHit.ToString(CultureInfo.InvariantCulture) });
collection.Add(toHit);
return(collection);
}
public static bool OverrideHitChanceStepNClamp(ToHit __instance, ref float __result, float baseChance, float totalModifiers)
{
try {
// A pretty intense routine that AI use to evaluate attacks, try catch disabled.
//Log( "OverrideHitChanceStepNClamp - Base Hit {0}, Modifier {1}", baseChance, totalModifiers );
__result = ClampHitChance(__instance.GetSteppedValue(baseChance, totalModifiers));
return(false);
} catch (Exception ex) { return(Error(ex)); }
}
private static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, Weapon weapon, ICombatant target,
Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
Mod.Log.Trace("TH:GAM entered");
if (attacker.HasMovedThisRound && attacker.JumpedLastRound)
{
__result = __result + (float)Mod.Config.ToHitSelfJumped;
}
}
private static float CounterNarc(ToHit tohit, AbstractActor attacker, Weapon wep, ICombatant target, Vector3 apos, Vector3 tpos, LineOfFireLevel lof, MeleeAttackType mat, bool calledshot)
{
AbstractActor at = target as AbstractActor;
if (at != null && at.HasIndirectFireImmunity && at.Combat.EffectManager.GetAllEffectsTargetingWithBaseID(at, "StatusEffect-NARC-IncomingAttBonus").Count > 0)
{
return(3);
}
return(0);
}
// Token: 0x06000026 RID: 38
private static void Postfix(ToHit __instance, ref string __result, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
if (UnityGameInstance.BattleTechGame.Simulation != null)
{
Mod.Log.Trace("TH:GAMD entered");
if (attacker.HasMovedThisRound && attacker.JumpedLastRound && attacker.SkillTactics < Mod.Config.TacticsSkillNegateJump)
{
__result = string.Format("{0}JUMPED {1:+#;-#}; ", __result, Mod.Config.ToHitSelfJumped);
}
}
}
public static void Postfix(ToHit __instance, AbstractActor attacker, ref float __result)
{
Pilot pilot = attacker.GetPilot();
int tactics = pilot.Tactics;
bool flag = tactics >= 8;
if (flag)
{
__result = 0f;
}
}
public static bool Prefix(ToHit __instance, ICombatant target, bool isMoraleAttack, ref float __result)
{
float num = 0f;
var modifier = target.StatCollection.GetValue <float>("ToHitOffensivePushModifier");
CombatGameState combat = Traverse.Create(__instance).Field("combat").GetValue <CombatGameState>();
num += combat.Constants.ToHit.ToHitOffensivePush;
__result = (!isMoraleAttack) ? 0f : num + target.StatCollection.GetValue <float>("ToHitOffensivePushModifier");
Logger.Debug($"Offensive Push modifier should be {combat.Constants.ToHit.ToHitOffensivePush} + {modifier}");
return(false);
}
// Token: 0x06000025 RID: 37
private static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
if (UnityGameInstance.BattleTechGame.Simulation != null && weapon != null)
{
Mod.Log.Trace("TH:GAM entered");
bool flag3;
if (!attacker.HasMovedThisRound || !attacker.JumpedLastRound || attacker.SkillTactics >= Mod.Config.TacticsSkillNegateJump)
{
CombatHUD combatHUD = ModState.CombatHUD;
bool flag2;
if (combatHUD == null)
{
flag2 = false;
}
else
{
CombatSelectionHandler selectionHandler = combatHUD.SelectionHandler;
flag2 = (((selectionHandler != null) ? selectionHandler.ActiveState : null) != null);
}
if (flag2)
{
CombatHUD combatHUD2 = ModState.CombatHUD;
object obj;
if (combatHUD2 == null)
{
obj = null;
}
else
{
CombatSelectionHandler selectionHandler2 = combatHUD2.SelectionHandler;
obj = ((selectionHandler2 != null) ? selectionHandler2.ActiveState : null);
}
if (obj is SelectionStateJump)
{
flag3 = (attacker.SkillTactics < Mod.Config.TacticsSkillNegateJump);
goto IL_D8;
}
}
flag3 = false;
}
else
{
flag3 = true;
}
IL_D8:
if (flag3)
{
__result += (float)Mod.Config.ToHitSelfJumped;
}
}
}
private static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, Weapon weapon, ICombatant target,
Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel)
{
string cacheKey = StraightTonnageCalculator.CacheKey(attacker, target);
bool keyExists = ModState.CachedComparisonMods.TryGetValue(cacheKey, out int modifier);
if (!keyExists)
{
modifier = StraightTonnageCalculator.Modifier(attacker, target);
ModState.CachedComparisonMods.Add(cacheKey, modifier);
}
__result += modifier;
}
public static void Postfix(ToHit __instance, ref string __result, AbstractActor attacker, Weapon weapon, ICombatant target)
{
if (attacker.UnitType != UnitType.Mech || target == null || attacker == null)
{
return;
}
var mech = attacker as Mech;
var mechTags = attacker.GetTags();
if (mechTags.Contains("BR_MQ_Vulcan") && target.UnitType == UnitType.Vehicle)
{
__result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.VulcanVehicleBonus);
}
//if (mechTags.Contains("BR_MQ_Mongoose") && weapon.Type == WeaponType.Laser)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.MongooseLaserAccuracy);
//if (mechTags.Contains("BR_MQ_SRMAccuracy") && weapon.Type == WeaponType.SRM)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.SRMAccuracyBoost);
//if (mechTags.Contains("BR_MQ_EnergySpecialization") && weapon.weaponDef.Category == WeaponCategory.Energy)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.EnergySpecializationBonus);
//if (mechTags.Contains("BR_MQ_EnergySpecialization") && weapon.weaponDef.Category != WeaponCategory.Energy)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.EnergySpecializationPenalty);
//if (mechTags.Contains("BR_MQ_Clint") && weapon.Type == WeaponType.Autocannon)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.ClintAutocannonBonus);
//if (Methods.TeamHasTag(attacker, "BR_MQ_MassiveSearchLight"))
// __result = string.Format("{0}TEAM QUIRK {1:+#;-#}; ", __result, Core.Settings.MassiveSearchLightTeamBonus);
//if (mechTags.Contains("BR_MQ_AwesomePPC") && weapon.weaponDef.Type == WeaponType.PPC)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.AwesomePPCBonus);
//if (mechTags.Contains("BR_MQ_AwesomePPC") && weapon.weaponDef.Category != WeaponCategory.Energy)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.AwesomeNonPPCPenalty);
//if (mechTags.Contains("BR_MQ_AllOrNothing") && (weapon.weaponDef.WeaponSubType == WeaponSubType.AC20 ||
// weapon.weaponDef.WeaponSubType == WeaponSubType.UAC20 || weapon.weaponDef.WeaponSubType == WeaponSubType.LB20X))
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.AllOrNothingAccuracy);
//if (mechTags.Contains("BR_MQ_BallisticComputer") && weapon.weaponDef.Category == WeaponCategory.Ballistic)
// __result = string.Format("{0}MECH QUIRK {1:+#;-#}; ", __result, Core.Settings.BallisticComputerBonus);
//***To-Be-Hit Section Follows***
//var targetName = target.Description.Name;
//if (targetName == null)
// return;
//if (targetName == "UrbanMech")
// __result = string.Format("{0}TARGET QUIRK {1:+#;-#}; ", __result, Core.Settings.UrbieToBeHitPenalty);
//if (targetName == "Huron Warrior")
// __result = string.Format("{0}TARGET QUIRK {1:+#;-#}; ", __result, Core.Settings.IntimidatingToBeHitPenalty);
//if (targetName == "Atlas")
// __result = string.Format("{0}TARGET QUIRK {1:+#;-#}; ", __result, Core.Settings.IntimidatingToBeHitPenalty);
}
public static void SmartIndirectReplaceIndirect(ToHit __instance, ref float __result, AbstractActor attacker, bool isIndirect)
{
try {
if (isIndirect || !ModifierList.AttackWeapon.IndirectFireCapable || !attacker.team.IsLocalPlayer)
{
return;
}
if (!ShouldSmartIndirect(attacker, ModifierList.Target))
{
return;
}
__result = __instance.GetIndirectModifier(attacker);
} catch (Exception ex) { Error(ex); }
}
public static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker)
{
Mod.Log.Trace("TH:GHM entered.");
if (attacker is Mech mech && mech.StatCollection.ContainsStatistic(ModStats.TurnsOverheated))
{
int turnsOverheated = mech.StatCollection.GetValue <int>(ModStats.TurnsOverheated);
if (turnsOverheated > 0)
{
float modifier = HeatHelper.GetHeatToHitModifierForTurn(turnsOverheated);
__result = modifier;
Mod.Log.Debug($"Mech {CombatantHelper.LogLabel(mech)} has overheat ToHit modifier:{modifier}");
}
else
{
__result = 0f;
}
}
}
public static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, ICombatant target)
{
try
{
if (__result == 0 || !WEAPON.IndirectFireCapable || !ShouldSmartIndirect(attacker, target))
{
return;
}
__result = attacker.team.IsLocalPlayer ? 0 : __instance.GetIndirectModifier(attacker);
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker)
{
Mod.Log.Trace("TH:GHM entered.");
if (attacker is Mech mech && mech.IsOverheated)
{
float penalty = 0f;
foreach (KeyValuePair <int, int> kvp in Mod.Config.Heat.Firing)
{
if (mech.CurrentHeat >= kvp.Key)
{
penalty = kvp.Value;
//Mod.Log.Debug($" attackPenalty:{penalty} from heat: {mech.CurrentHeat} >= {kvp.Key}");
}
}
__result = penalty;
}
}
public static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, bool isIndirect)
{
try
{
if (isIndirect || !WEAPON.IndirectFireCapable || !attacker.team.IsLocalPlayer || !ShouldSmartIndirect(attacker, TARGET))
{
return;
}
__result = __instance.GetIndirectModifier(attacker);
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void Postfix(ToHit __instance, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot, ref string __result)
{
string str = string.Empty;
bool flag = lofLevel < LineOfFireLevel.LOFObstructed && (CustomAmmoCategories.getIndirectFireCapable(weapon));
float weaponDirectFireModifier = CustomAmmoCategories.getDirectFireModifier(weapon);
if (flag == false)
{
//CustomAmmoCategoriesLog.Log.LogWrite(attacker.DisplayName + " has LOS on " + target.DisplayName + ". Apply DirectFireModifier " + weaponDirectFireModifier + "\n");
if (!NvMath.FloatIsNearZero(weaponDirectFireModifier))
{
__result = string.Format("{0}WEAPON-DIRECT-FIRE {1:+#;-#}; ", (object)__result, (object)(int)weaponDirectFireModifier);
}
}
CombatGameState combat = (CombatGameState)typeof(ToHit).GetField("combat", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
return;
}
public static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker)
{
Mod.Log.Trace?.Write("TH:GHM entered.");
if (attacker is Mech mech && mech.IsOverheated)
{
float penalty = 0f;
foreach (KeyValuePair <int, int> kvp in Mod.Config.Heat.Firing)
{
if (mech.CurrentHeat >= kvp.Key)
{
penalty = kvp.Value;
}
}
Mod.Log.Trace?.Write($" AttackPenalty: {penalty:+0;-#} from heat: {mech.CurrentHeat} for actor: {attacker.DistinctId()}");
__result = penalty;
}
}
private static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker)
{
if (attacker is Mech)
{
Mech mech = (Mech)attacker;
int turnsOverheated = mech.StatCollection.GetValue <int>("TurnsOverheated");
if (turnsOverheated > 0)
{
float modifier = CBTHeat.GetHeatToHitModifierForTurn(turnsOverheated);
__result = modifier;
}
else
{
__result = 0f;
}
}
}
static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, Weapon weapon, ICombatant target,
Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
Mod.Log.Trace?.Write("TH:GAM entered");
if (__instance == null || weapon == null)
{
return;
}
if (
(attacker.HasMovedThisRound && attacker.JumpedLastRound) ||
(SharedState.CombatHUD?.SelectionHandler?.ActiveState != null &&
SharedState.CombatHUD?.SelectionHandler?.ActiveState is SelectionStateJump)
)
{
__result += (float)Mod.Config.ToHitSelfJumped;
}
}
public static bool OverrideHitChanceDiminishing(ToHit __instance, ref float __result, float baseChance, float totalModifiers)
{
try {
// A pretty intense routine that AI use to evaluate attacks
int mod = Mathf.RoundToInt(totalModifiers);
if (mod < 0)
{
mod = Math.Min(Settings.DiminishingBonusMax, -mod);
baseChance *= diminishingBonus [mod - 1];
}
else if (mod > 0)
{
mod = Math.Min(Settings.DiminishingPenaltyMax, mod);
baseChance *= diminishingPenalty[mod - 1];
}
__result = ClampHitChance(baseChance);
return(false);
} catch (Exception ex) { return(Error(ex)); }
}
private static void Postfix(ToHit __instance, ref float __result, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot)
{
Pilot pilot = attacker.GetPilot();
try {
Pilot TargetPilot = target.GetPilot();
if (TargetPilot.pilotDef.PilotTags.Contains("pilot_reckless"))
{
__result = __result + (float)settings.pilot_reckless_ToBeHitBonus;
}
if (TargetPilot.pilotDef.PilotTags.Contains("pilot_cautious"))
{
__result = __result + (float)settings.pilot_reckless_ToBeHitBonus;
}
if (TargetPilot.pilotDef.PilotTags.Contains("pilot_jinxed"))
{
__result = __result + (float)settings.pilot_jinxed_ToBeHitBonus;
}
if (TargetPilot.pilotDef.PilotTags.Contains("pilot_jinxed"))
{
__result = __result + (float)settings.pilot_reckless_ToBeHitBonus;
}
}
catch (Exception) {
}
if (pilot.pilotDef.PilotTags.Contains("pilot_reckless"))
{
__result = __result + (float)settings.pilot_reckless_ToHitBonus;
}
if (pilot.pilotDef.PilotTags.Contains("pilot_cautious"))
{
__result = __result + (float)settings.pilot_reckless_ToHitBonus;
}
if (pilot.pilotDef.PilotTags.Contains("pilot_drunk") && pilot.pilotDef.TimeoutRemaining > 0)
{
__result = __result + (float)settings.pilot_drunk_ToHitBonus;
}
if (pilot.pilotDef.PilotTags.Contains("pilot_lostech") && weapon.componentDef.ComponentTags.Contains("component_type_lostech"))
{
__result = __result + (float)settings.pilot_lostech_ToHitBonus;
}
}
public static void Postfix(ToHit __instance, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot, ref float __result)
{
bool flag = lofLevel < LineOfFireLevel.LOFObstructed && (CustomAmmoCategories.getIndirectFireCapable(weapon));
float num = __result;
if (flag == false)
{
//float directFireModifier = CustomAmmoCategories.getDirectFireModifier(weapon);
//CustomAmmoCategoriesLog.Log.LogWrite(attacker.DisplayName+" has LOS on "+target.DisplayName+ ". Apply DirectFireModifier "+directFireModifier+"\n");
num += CustomAmmoCategories.getDirectFireModifier(weapon);
}
CombatGameState combat = (CombatGameState)typeof(ToHit).GetField("combat", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
if ((double)num < 0.0 && !combat.Constants.ResolutionConstants.AllowTotalNegativeModifier)
{
num = 0.0f;
}
__result = num;
return;
}
/*static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
* {
* var targetPropertyGetter = AccessTools.Property(typeof(Weapon), "IndirectFireCapable").GetGetMethod();
* var replacementMethod = AccessTools.Method(typeof(ToHit_GetAllModifiers), nameof(IndirectFireCapable));
* return Transpilers.MethodReplacer(instructions, targetPropertyGetter, replacementMethod);
* }
*
* private static bool IndirectFireCapable(Weapon weapon)
* {
* //CustomAmmoCategoriesLog.Log.LogWrite("get ToHit_GetAllModifiers IndirectFireCapable\n");
* return CustomAmmoCategories.getIndirectFireCapable(weapon);
* }*/
public static bool Prefix(ToHit __instance, AbstractActor attacker, Weapon weapon, ICombatant target, Vector3 attackPosition, Vector3 targetPosition, LineOfFireLevel lofLevel, bool isCalledShot, ref float __result)
{
bool flag = lofLevel < LineOfFireLevel.LOFObstructed && (CustomAmmoCategories.getIndirectFireCapable(weapon));
float num = __instance.GetRangeModifier(weapon, attackPosition, targetPosition)
+ __instance.GetCoverModifier(attacker, target, lofLevel)
+ __instance.GetSelfSpeedModifier(attacker)
+ __instance.GetSelfSprintedModifier(attacker)
+ __instance.GetSelfArmMountedModifier(weapon)
+ __instance.GetStoodUpModifier(attacker)
+ __instance.GetHeightModifier(attackPosition.y, targetPosition.y)
+ __instance.GetHeatModifier(attacker)
+ __instance.GetTargetTerrainModifier(target, targetPosition, false)
+ __instance.GetSelfTerrainModifier(attackPosition, false)
+ __instance.GetTargetSpeedModifier(target, weapon)
+ __instance.GetSelfDamageModifier(attacker, weapon)
+ __instance.GetTargetSizeModifier(target)
+ __instance.GetTargetShutdownModifier(target, false)
+ __instance.GetTargetProneModifier(target, false)
+ __instance.GetWeaponAccuracyModifier(attacker, weapon)
+ __instance.GetAttackerAccuracyModifier(attacker)
+ __instance.GetEnemyEffectModifier(target)
+ __instance.GetRefireModifier(weapon)
+ __instance.GetTargetDirectFireModifier(target, flag)
+ __instance.GetIndirectModifier(attacker, flag)
+ __instance.GetMoraleAttackModifier(target, isCalledShot);
if (flag == false)
{
float directFireModifier = CustomAmmoCategories.getDirectFireModifier(weapon);
CustomAmmoCategoriesLog.Log.LogWrite(attacker.DisplayName + " has LOS on " + target.DisplayName + ". Apply DirectFireModifier " + directFireModifier + "\n");
num += CustomAmmoCategories.getDirectFireModifier(weapon);
}
CombatGameState combat = (CombatGameState)typeof(ToHit).GetField("combat", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
if ((double)num < 0.0 && !combat.Constants.ResolutionConstants.AllowTotalNegativeModifier)
{
num = 0.0f;
}
__result = num;
return(false);
}
