public static void Prefix(CombatHUDWeaponSlot __instance, ICombatant target)
{
CombatHUDWeaponSlot slot = __instance;
WEAPON = slot.DisplayedWeapon;
TARGET = target;
}
public static void Postfix(CombatHUDWeaponSlot __instance, CombatGameState ___Combat, ICombatant target)
{
try
{
if (DemandingJumps.Settings.ToHitSelfJumpedSpareAI && !___Combat.LocalPlayerTeam.IsActive)
{
return;
}
Logger.Info("[CombatHUDWeaponSlot_SetHitChance_POSTFIX] CombatGameState.LocalPlayerTeam.IsActive: " + ___Combat.LocalPlayerTeam.IsActive);
AbstractActor attacker = __instance.DisplayedWeapon.parent;
bool AttackerJumpedThisRound = attacker.HasMovedThisRound && attacker.JumpedLastRound;
Logger.Info("[CombatHUDWeaponSlot_SetHitChance_POSTFIX] Fields.JumpPreview: " + Fields.JumpPreview);
Logger.Info("[CombatHUDWeaponSlot_SetHitChance_POSTFIX] AttackerJumpedThisRound: " + AttackerJumpedThisRound);
if (AttackerJumpedThisRound)
{
int ToHitSelfJumpedModifier = Utilities.GetAttackerJumpedAccuracyModifier(attacker);
Traverse AddToolTipDetail = Traverse.Create(__instance).Method("AddToolTipDetail", "SELF JUMPED", ToHitSelfJumpedModifier);
Logger.Info($"[CombatHUDWeaponSlot_SetHitChance_POSTFIX] Invoking AddToolTipDetail for ToHitSelfJumped: {ToHitSelfJumpedModifier}");
AddToolTipDetail.GetValue();
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void CombatHUDWeaponSlot_UpdateToolTipsFiring_Postfix(CombatHUDWeaponSlot __instance, ICombatant target, CombatGameState ___Combat, CombatHUD ___HUD, int ___modifier)
{
if (___HUD.SelectionHandler.ActiveState.SelectionType == SelectionType.FireMorale)
{
Mod.Log.Trace("CHUDWS:UTTF:Post entered.");
AbstractActor attacker = ___HUD.SelectedActor;
// Calculate called shot modifier
int pilotValue = CalledShotHelper.GetCalledShotModifier(___HUD.SelectedActor.GetPilot());
int unitMod = 0;
if (attacker.StatCollection.ContainsStatistic(ModStats.CalledShotMod))
{
unitMod = attacker.StatCollection.GetStatistic(ModStats.CalledShotMod).Value <int>();
}
int calledShotMod = pilotValue + unitMod;
Mod.Log.Debug($" Called Shot from pilot:{attacker.GetPilot().Name} => pilotValue:{pilotValue} + unitMod:0 = calledShotMod:{calledShotMod}");
if (calledShotMod != 0)
{
AddMoraleToolTip(__instance, ___Combat.Constants.CombatUIConstants.MoraleAttackDescription.Name, calledShotMod);
}
}
}
private static void Postfix(CombatHUDWeaponSlot __instance, ICombatant target, Weapon ___displayedWeapon, CombatHUD ___HUD)
{
if (__instance == null || ___displayedWeapon == null || ___HUD.SelectedActor == null || target == null)
{
return;
}
Mod.Log.Trace?.Write("CHUDWS:SHC - entered.");
Traverse AddToolTipDetailMethod = Traverse.Create(__instance).Method("AddToolTipDetail",
new Type[] { typeof(string), typeof(int) });
AbstractActor attacker = __instance.DisplayedWeapon.parent;
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);
}
string localText = new Localize.Text(Mod.LocalizedText.Label[ModText.LT_AttackModSizeDelta]).ToString();
AddToolTipDetailMethod.GetValue(new object[] { localText, modifier });
}
public static void SetToolTips(CombatHUDWeaponSlot slot, Dictionary <string, Func <AttackModifier> > factors)
{
try {
AttackPos = ActiveState.PreviewPos;
tip = slot.ToolTipHoverElement;
thisModifier = "(Init)";
int TotalModifiers = 0;
foreach (var modifier in factors)
{
thisModifier = modifier.Key;
AttackModifier mod = modifier.Value();
TotalModifiers += AddToolTipDetail(mod);
}
if (TotalModifiers < 0 && !CombatConstants.ResolutionConstants.AllowTotalNegativeModifier)
{
TotalModifiers = 0;
}
tip.BasicModifierInt = Settings.ReverseInCombatModifier ? -TotalModifiers : TotalModifiers;
} catch (Exception) {
// Reset before giving up
tip?.DebuffStrings.Clear();
tip?.BuffStrings.Clear();
throw;
}
}
private static void AddToTotalDamage(float dmg, CombatHUDWeaponSlot slot)
{
Weapon w = slot.DisplayedWeapon;
if (!w.IsEnabled)
{
return;
}
float chance = slot.HitChance, multiplied = dmg * w.ShotsWhenFired;
ICombatant target = HUD.SelectedTarget;
if (chance <= 0)
{
if (target != null)
{
return; // Hit Chance is -999.9 if it can't fire at target (Method ClearHitChance)
}
chance = 1; // Otherwise, preview full damage when no target is selected.
}
SelectionState state = HUD.SelectionHandler.ActiveState;
if (state is SelectionStateFireMulti multi &&
state.AllTargetedCombatants.Contains(HUD.SelectedTarget) &&
HUD.SelectedTarget != multi.GetSelectedTarget(w))
{
return;
}
TotalDamage += multiplied;
AverageDamage += multiplied * chance;
}
// can't remember what the f**k I was trying to do here...
public static bool Prefix(CombatHUDWeaponSlot __instance, ICombatant target, CombatHUD ___HUD)
{
Logger.Debug($"----- Start UpdateToolTipsFiring ---------");
bool isMoraleAttack = ___HUD.SelectionHandler.ActiveState.SelectionType == SelectionType.FireMorale;
Logger.Debug($"Called shot: {isMoraleAttack}");
Logger.Debug($"Setting attackModifier");
var combat = Traverse.Create(__instance).Field("Combat").GetValue <CombatGameState>();
var attackModifier = combat.ToHit.GetMoraleAttackModifier(target, isMoraleAttack);
Logger.Debug($"Trying to apply modifier");
try
{
Traverse.Create(__instance).Method("AddToolTipDetail",
new Type[] { typeof(string), typeof(int) },
new object[] { "OffPush MOD", attackModifier });
Logger.Debug($"Modifier applied: {attackModifier}");
Logger.Debug("Buffs:");
__instance.ToolTipHoverElement.BuffStrings.ForEach(x => Logger.Debug(x));
Logger.Debug("Debuffs:");
__instance.ToolTipHoverElement.DebuffStrings.ForEach(x => Logger.Debug(x));
}
catch (Exception e)
{
Logger.LogError(e);
}
Logger.Debug($"----- End UpdateToolTipsFiring -----------{Environment.NewLine}");
return(false);
}
// Original method fails if a potential melee target is hovered/selected as the color is determined by the current evasive pips preview UIModule IF THAT IS VISIBLE...
// ...which IT IS NOT while contemplating a melee attack. Fallback is current evasive pips of the parent actor which might be much more than the current pathing suggests...
// ...resulting in a coil-charged color for the default damage. Sigh...
public static void Postfix(CombatHUDWeaponSlot __instance, ref Color __result, Color fallbackColor)
{
// Simple workaround: Change the color to "charged" depending on displayed damage value (which is correctly determined by Weapon.GetCOILDamageFromEvasivePips()!)
// Far from good but at least not broken
try
{
//displayedDamage = float.Parse(__instance.DamageText.text, CultureInfo.InvariantCulture.NumberFormat);
float displayedDamage = 0;
if (float.TryParse(__instance.DamageText.text, out displayedDamage))
{
Logger.Info($"[CombatHUDWeaponSlot_GetWeaponCOILStateColor_POSTFIX] PARSED __instance.DamageText.text ({__instance.DamageText.text}): {displayedDamage}");
}
else
{
Logger.Info($"[CombatHUDWeaponSlot_GetWeaponCOILStateColor_POSTFIX] PARSING FAILED: __instance.DamageText.text: {__instance.DamageText.text}");
}
// It's necessary to even look at the WeaponDef directly because the getter of Weapon.DamagePerShot is polluted with COIL-Logic
float weaponDefDamage = __instance.DisplayedWeapon.weaponDef.Damage;
//Logger.Info($"[CombatHUDWeaponSlot_GetWeaponCOILStateColor_POSTFIX] displayedDamage: {displayedDamage}");
//Logger.Info($"[CombatHUDWeaponSlot_GetWeaponCOILStateColor_POSTFIX] weaponDefDamage: {weaponDefDamage}");
if (displayedDamage <= weaponDefDamage)
{
__result = fallbackColor;
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
static void Postfix(CombatHUDWeaponSlot __instance, ICombatant target, Weapon ___displayedWeapon, CombatHUD ___HUD)
{
if (__instance == null || ___displayedWeapon == null || ___HUD.SelectedActor == null || target == null)
{
return;
}
Mod.Log.Trace?.Write("CHUDWS:SHC entered");
if (___HUD.SelectionHandler.ActiveState.SelectionType == SelectionType.FireMorale)
{
int calledShotMod = ActorHelper.CalledShotModifier(___HUD.SelectedActor);
if (calledShotMod != 0)
{
Traverse addToolTipDetailT = Traverse.Create(__instance)
.Method("AddToolTipDetail", new Type[] { typeof(string), typeof(int) });
string localText = new Text(Mod.LocalizedText.Modifiers[ModText.Mod_CalledShot]).ToString();
addToolTipDetailT.GetValue(new object[] { localText, calledShotMod });
Mod.Log.Debug?.Write($"Adding calledShot tooltip with text: {localText} and mod: {calledShotMod}");
}
Mod.Log.Debug?.Write($"Updated TooltipsForFiring for actor: {___HUD.SelectedActor} with mod: {calledShotMod}");
}
else
{
Mod.Log.Debug?.Write("Not FireMorale, skipping!");
}
}
public static void Postfix(CombatHUDWeaponSlot __instance, Weapon ___displayedWeapon)
{
try
{
if (___displayedWeapon != null && ___displayedWeapon.Type == WeaponType.COIL)
{
//float displayedDamage = float.Parse(__instance.DamageText.text, CultureInfo.InvariantCulture.NumberFormat);
float displayedDamage = 0;
if (float.TryParse(__instance.DamageText.text, out displayedDamage))
{
Logger.Info($"[CombatHUDWeaponSlot_ShowTextColor_POSTFIX] PARSED __instance.DamageText.text ({__instance.DamageText.text}): {displayedDamage}");
}
else
{
Logger.Info($"[CombatHUDWeaponSlot_ShowTextColor_POSTFIX] PARSING FAILED: __instance.DamageText.text: {__instance.DamageText.text}");
}
float weaponDefDamage = __instance.DisplayedWeapon.weaponDef.Damage;
//Logger.Info($"[CombatHUDWeaponSlot_ShowTextColor_POSTFIX] displayedDamage: {displayedDamage}");
//Logger.Info($"[CombatHUDWeaponSlot_ShowTextColor_POSTFIX] weaponDefDamage: {weaponDefDamage}");
if (displayedDamage > weaponDefDamage)
{
__instance.DamageText.color = LazySingletonBehavior <UIManager> .Instance.UILookAndColorConstants.EvasivePipsCharged.color;
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private static void Postfix(CombatHUDWeaponSlot __instance, ICombatant target)
{
AbstractActor actor = __instance.DisplayedWeapon.parent;
var _this = Traverse.Create(__instance);
Pilot pilot = actor.GetPilot();
if (pilot.pilotDef.PilotTags.Contains("pilot_reckless"))
{
_this.Method("AddToolTipDetail", "RECKLESS", settings.pilot_reckless_ToHitBonus).GetValue();
}
if (pilot.pilotDef.PilotTags.Contains("pilot_cautious"))
{
_this.Method("AddToolTipDetail", "CAUTIOUS", settings.pilot_cautious_ToHitBonus).GetValue();
}
if (pilot.pilotDef.PilotTags.Contains("pilot_drunk") && pilot.pilotDef.TimeoutRemaining > 0)
{
_this.Method("AddToolTipDetail", "DRUNK", settings.pilot_drunk_ToHitBonus).GetValue();
}
if (__instance.tag.Contains("component_type_lostech") && pilot.pilotDef.PilotTags.Contains("pilot_lostech"))
{
_this.Method("AddToolTipDetail", "LOSTECH TECH", settings.pilot_lostech_ToHitBonus).GetValue();
}
if (pilot.pilotDef.PilotTags.Contains("pilot_jinxed"))
{
_this.Method("AddToolTipDetail", "JINXED", settings.pilot_jinxed_ToHitBonus).GetValue();
}
}
static void Postfix(CombatHUDWeaponSlot __instance, Weapon ___displayedWeapon, CombatHUD ___HUD)
{
if (__instance == null || ___displayedWeapon == null || ___HUD.SelectedActor == null ||
!Mod.Config.Melee.FilterCanUseInMeleeWeaponsByAttack)
{
return;
}
MeleeAttack selectedAttack = ModState.GetSelectedAttack(___HUD.SelectedActor);
if (selectedAttack != null)
{
Mod.UILog.Debug?.Write($"Checking ranged weapons attacker: {___HUD.SelectedActor.DistinctId()} using selectedAttack: {selectedAttack.Label}");
// Check if the weapon can fire according to the select melee type
bool isAllowed = selectedAttack.IsRangedWeaponAllowed(___displayedWeapon);
Mod.UILog.Debug?.Write($"Ranged weapon '{___displayedWeapon.UIName}' can fire in melee by type? {isAllowed}");
if (!isAllowed)
{
Mod.UILog.Debug?.Write($"Disabling weapon from selection");
__instance.ToggleButton.isChecked = false;
Traverse showDisabledHexT = Traverse.Create(__instance).Method("ShowDisabledHex");
showDisabledHexT.GetValue();
}
}
//else
//{
// // No selected attack, so revert the weapon to the state it should have
// __instance.ToggleButton.isChecked = ___displayedWeapon.IsEnabled && !___displayedWeapon.IsDisabled;
//}
}
[HarmonyPriority(Priority.HigherThanNormal)] // Above alexanderabramov's Real Hit Chance mod
public static bool OverrideDisplayedHitChance(CombatHUDWeaponSlot __instance, float chance)
{
try {
HitChance.Invoke(__instance, new object[] { chance });
__instance.HitChanceText.text = string.Format(WeaponHitChanceFormat, Mathf.Clamp(chance * 100f, 0f, 100f));
Refresh.Invoke(__instance, null);
return(false);
} catch (Exception ex) { return(Error(ex)); }
}
public static bool OverrideRangedToolTips(CombatHUDWeaponSlot __instance, ICombatant target)
{
try {
SetToolTips(__instance, RangedModifiers);
return(false);
} catch (Exception ex) {
return(Error(new ApplicationException("Error in ranged modifier '" + thisModifier + "'", ex)));
}
}
public static void SaveRangedToolTipState(CombatHUDWeaponSlot __instance, ICombatant target)
{
try {
CombatHUDWeaponSlot slot = __instance;
LineOfFire = ActiveState.FiringPreview.GetPreviewInfo(target as AbstractActor).LOFLevel;
IsMoraleAttack = ActiveState.SelectionType == SelectionType.FireMorale;
SaveStates(HUD.SelectedActor, target, slot.DisplayedWeapon);
} catch (Exception ex) { Error(ex); }
}
private static void Postfix(CombatHUDWeaponSlot __instance, ICombatant target)
{
AbstractActor actor = __instance.DisplayedWeapon.parent;
var _this = Traverse.Create(__instance);
if (actor.HasMovedThisRound && actor.JumpedLastRound)
{
_this.Method("AddToolTipDetail", "JUMPED SELF", CBTMovement.Settings.ToHitSelfJumped).GetValue();
}
}
public static void ShowBaseMeleeChance(CombatHUDWeaponSlot __instance, ICombatant target)
{
try {
if (HUD.SelectedActor is Mech mech)
{
float baseChance = RollModifier.StepHitChance(Combat.ToHit.GetBaseMeleeToHitChance(mech)) * 100;
__instance.ToolTipHoverElement.BuffStrings.Add(new Text("{0} {1} = " + BaseChanceFormat, Translate(Pilot.PILOTSTAT_PILOTING), mech.SkillPiloting, baseChance));
}
} catch (Exception ex) { Error(ex); }
}
public static bool BypassTotalSlotHighlight(CombatHUDWeaponSlot __instance)
{
try {
if (__instance.DisplayedWeapon == null)
{
return(false); // Skip highlight if no weapon in this slot
}
return(true);
} catch (Exception ex) { return(Error(ex)); }
}
public static void ShowNeutralRange(CombatHUDWeaponSlot __instance, ICombatant target)
{
try {
ModifierList.AttackModifier range = rangedPenalty();
if (range.Value != 0)
{
return;
}
__instance.ToolTipHoverElement.BuffStrings.Add(new Text(range.DisplayName));
} catch (Exception ex) { Error(ex); }
}
private static void AddMoraleToolTip(CombatHUDWeaponSlot instance, string description, int modifier)
{
Mod.Log.Trace($"CHUDWS:UTTF:AMTT - adding desc:{description} with modifier:{modifier}.");
if (modifier < 0)
{
instance.ToolTipHoverElement.BuffStrings.Add(new Text("{0} {1:+0;-#}", new object[] { description, modifier }));
}
else if (modifier > 0)
{
instance.ToolTipHoverElement.DebuffStrings.Add(new Text("{0} {1:+0;-#}", new object[] { description, modifier }));
}
}
public static bool OverrideMeleeToolTips(CombatHUDWeaponSlot __instance, ICombatant target)
{
try {
CombatHUDWeaponSlot slot = __instance;
bool isDFA = (bool)contemplatingDFA?.Invoke(slot, new object[] { target });
AttackType = isDFA ? MeleeAttackType.DFA : MeleeAttackType.Punch;
SaveStates(HUD.SelectedActor, target, slot.DisplayedWeapon);
SetToolTips(__instance, MeleeModifiers);
return(false);
} catch (Exception ex) {
return(Error(new ApplicationException("Error in melee modifier '" + thisModifier + "'", ex)));
}
}
// ============ Reverse Modifier Sign ============
public static void ReverseModifiersSign(CombatHUDWeaponSlot __instance)
{
try {
foreach (Text txt in __instance.ToolTipHoverElement.BuffStrings)
{
ReverseModifierSign(txt);
}
foreach (Text txt in __instance.ToolTipHoverElement.DebuffStrings)
{
ReverseModifierSign(txt);
}
__instance.ToolTipHoverElement.BasicModifierInt *= -1;
} catch (Exception ex) { Error(ex); }
}
private static void Postfix(CombatHUDWeaponSlot __instance, ICombatant target)
{
Mod.Log.Trace("CHUDWS:SHC entered");
AbstractActor actor = __instance.DisplayedWeapon.parent;
var _this = Traverse.Create(__instance);
if (actor.HasMovedThisRound && actor.JumpedLastRound)
{
Traverse addToolTipDetailT = Traverse.Create(__instance).Method("AddToolTipDetail", "JUMPED SELF", Mod.Config.ToHitSelfJumped);
Mod.Log.Trace($"Invoking addToolTipDetail for: JUMPED SELF = {Mod.Config.ToHitSelfJumped}");
addToolTipDetailT.GetValue();
}
}
public static void Postfix(CombatHUDWeaponSlot __instance, string description, int modifier)
{
try {
if (modifier != 0)
{
return;
}
__instance.ToolTipHoverElement.BuffStrings.Add(new Text("{0} +0", new object[1]
{
(object)description
}));
} catch (Exception ex) {
Log.Error?.TWL(0, ex.ToString(), true);
}
}
public static void Prefix(CombatHUDWeaponSlot __instance, ref bool sprinting)
{
try
{
Logger.Info($"[CombatHUDWeaponSlot_RefreshDisplayedWeapon_PREFIX] Fields.JuggernautCharges: {Fields.JuggernautCharges}");
if (Fields.JuggernautCharges && !sprinting)
{
sprinting = true;
}
Logger.Info($"[CombatHUDWeaponSlot_RefreshDisplayedWeapon_PREFIX] sprinting: {sprinting}");
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void ShowTotalDamageSlot(CombatHUDWeaponPanel __instance, int topIndex, List <CombatHUDWeaponSlot> ___WeaponSlots)
{
try {
TotalSlot = null;
if (topIndex <= 0 || topIndex >= ___WeaponSlots.Count || __instance.DisplayedActor == null)
{
return;
}
TotalSlot = ___WeaponSlots[topIndex];
TotalSlot.transform.parent.gameObject.SetActive(true);
TotalSlot.DisplayedWeapon = null;
TotalSlot.WeaponText.text = GetTotalLabel();
TotalSlot.AmmoText.text = "";
TotalSlot.MainImage.color = Color.clear;
TotalSlot.ToggleButton.childImage.color = Color.clear;
} catch (Exception ex) { Error(ex); }
}
public static void Postfix(CombatHUDWeaponSlot __instance)
{
try
{
Weapon weapon = __instance.DisplayedWeapon;
if (IsUltraAutocannon(weapon) && IsJammed(weapon))
{
//Logger.Info($"[CombatHUDWeaponSlot_UpdateToolTipsSelf_POSTFIX] Adding tooltip details for jammed UAC");
__instance.ToolTipHoverElement.DebuffStrings.Add(new Text("JAMMED", new object[] { }));
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x06000027 RID: 39
private static void Postfix(CombatHUDWeaponSlot __instance, ICombatant target)
{
if (UnityGameInstance.BattleTechGame.Simulation != null)
{
Mod.Log.Trace("CHUDWS:SHC entered");
AbstractActor parent = __instance.DisplayedWeapon.parent;
Traverse.Create(__instance);
if (parent.HasMovedThisRound && parent.JumpedLastRound && parent.SkillTactics < Mod.Config.TacticsSkillNegateJump)
{
Traverse traverse = Traverse.Create(__instance).Method("AddToolTipDetail", new object[]
{
"JUMPED SELF",
Mod.Config.ToHitSelfJumped
});
Mod.Log.Debug(string.Format("Invoking addToolTipDetail for: JUMPED SELF = {0}", Mod.Config.ToHitSelfJumped));
traverse.GetValue();
}
}
}
public static void UpdateWeaponTooltip(CombatHUDWeaponSlot __instance)
{
try {
Weapon weapon = __instance.DisplayedWeapon;
List <Text> spec = __instance.ToolTipHoverElement?.WeaponStrings;
if (weapon == null || spec == null || spec.Count != 3)
{
return;
}
if (Settings.ShowWeaponProp && !string.IsNullOrEmpty(weapon.weaponDef.BonusValueA))
{
spec[0] = new Text(string.IsNullOrEmpty(weapon.weaponDef.BonusValueB) ? "{0}" : "{0}, {1}", weapon.weaponDef.BonusValueA, weapon.weaponDef.BonusValueB);
}
if (Settings.WeaponRangeFormat != null)
{
spec[2] = new Text(Settings.WeaponRangeFormat, weapon.MinRange, weapon.ShortRange, weapon.MediumRange, weapon.LongRange, weapon.MaxRange);
}
} catch (Exception ex) { Error(ex); }
}
static void Postfix(CombatHUDWeaponSlot __instance, Weapon ___displayedWeapon, CombatHUD ___HUD, int ___displayedHeat)
{
if (__instance == null || ___displayedWeapon == null || ___HUD.SelectedActor == null)
{
return;
}
Mod.UILog.Trace?.Write("CHUDWS:GTTS entered");
// Check melee patches
MeleeAttack selectedAttack = ModState.GetSelectedAttack(___HUD.SelectedActor);
if (selectedAttack != null && ___displayedWeapon.Type == WeaponType.Melee)
{
if (___displayedWeapon.WeaponSubType == WeaponSubType.Melee)
{
float targetDamage = selectedAttack.TargetDamageClusters.Sum();
Mod.UILog.Trace?.Write($" - Extra Strings for type: {___displayedWeapon.Type} && {___displayedWeapon.WeaponSubType} " +
$"=> Damage: {targetDamage} instability: {selectedAttack.TargetInstability} " +
$"heat: {___displayedHeat}");
__instance.ToolTipHoverElement.ExtraStrings = new List <Text>
{
new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Weapon_Hover_Damage], targetDamage),
new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Weapon_Hover_Instability], selectedAttack.TargetInstability),
new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Weapon_Hover_Heat], ___displayedHeat)
};
}
else if (___displayedWeapon.WeaponSubType == WeaponSubType.DFA)
{
float targetDamage = selectedAttack.TargetDamageClusters.Sum();
Mod.UILog.Trace?.Write($" - Extra Strings for type: {___displayedWeapon.Type} && {___displayedWeapon.WeaponSubType} " +
$"=> Damage: {targetDamage} instability: {selectedAttack.TargetInstability} " +
$"heat: {___displayedHeat}");
__instance.ToolTipHoverElement.ExtraStrings = new List <Text>
{
new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Weapon_Hover_Damage], targetDamage),
new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Weapon_Hover_Instability], selectedAttack.TargetInstability),
new Text(Mod.LocalizedText.Labels[ModText.LT_Label_Weapon_Hover_Heat], ___displayedHeat)
};
}
}
}
