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) }; } } }