Beispiel #1
0
 //public static bool Prepare() { return false; }
 public static void Postfix(CombatHUDWeaponPanel __instance, AbstractActor value)
 {
     if (CombatHUDEquipmentPanel.Instance != null)
     {
         CombatHUDEquipmentPanel.Instance.InitDisplayedEquipment(value);
     }
     ;
 }
        public static void Prefix(CombatHUDWeaponPanel __instance, AbstractActor ___displayedActor)
        {
            if (__instance == null || ___displayedActor == null)
            {
                return;
            }
            Mod.Log.Trace?.Write("CHUDWP:RDW - entered.");

            Traverse targetT        = Traverse.Create(__instance).Property("target");
            Traverse hoveredTargetT = Traverse.Create(__instance).Property("hoveredTarget");

            Traverse       HUDT        = Traverse.Create(__instance).Property("HUD");
            CombatHUD      HUD         = HUDT.GetValue <CombatHUD>();
            SelectionState activeState = HUD.SelectionHandler.ActiveState;
            ICombatant     target;

            if (activeState != null && activeState is SelectionStateMove)
            {
                target = hoveredTargetT.GetValue <ICombatant>();
                if (target == null)
                {
                    target = targetT.GetValue <ICombatant>();
                }
            }
            else
            {
                target = targetT.GetValue <ICombatant>();
                if (target == null)
                {
                    target = hoveredTargetT.GetValue <ICombatant>();
                }
            }

            if (target == null)
            {
                return;
            }

            EWState attackerState = new EWState(___displayedActor);

            Mod.Log.Debug?.Write($"Attacker ({CombatantUtils.Label(___displayedActor)} => EWState: {attackerState}");
            bool canSpotTarget = VisualLockHelper.CanSpotTarget(___displayedActor, ___displayedActor.CurrentPosition,
                                                                target, target.CurrentPosition, target.CurrentRotation, ___displayedActor.Combat.LOS);
            SensorScanType sensorScan = SensorLockHelper.CalculateSharedLock(target, ___displayedActor);

            Mod.Log.Debug?.Write($"  canSpotTarget: {canSpotTarget}  sensorScan: {sensorScan}");

            if (target is AbstractActor targetActor)
            {
                EWState targetState = new EWState(targetActor);
                Mod.Log.Debug?.Write($"Target ({CombatantUtils.Label(targetActor)} => EWState: {targetState}");
            }
        }
Beispiel #3
0
 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); }
 }
Beispiel #4
0
 //public static bool Prepare() { return false; }
 public static void Postfix(CombatHUDWeaponPanel __instance, List <CombatHUDEquipmentSlot> ___EquipmentSlots, AbstractActor ___displayedActor)
 {
     EquipmentSlots = ___EquipmentSlots;
     for (int index = 1; index < EquipmentSlots.Count; ++index)
     {
         EquipmentSlots[index].DisableButton();
         EquipmentSlots[index].gameObject.SetActive(false);
     }
     if (EquipmentSlots.Count > 0)
     {
         EquipmentSlots[0].gameObject.transform.parent.gameObject.SetActive(false);
         EquipmentSlots[0].gameObject.SetActive(false);
         EquipmentSlots[0].InitButton(SelectionType.ActiveProbe, null, null, "ACTIVE_COMPONENTS_MENU", "Active components menu", ___displayedActor);
         EquipmentSlots[0].Text.SetText("COMPONENTS", (object[])Array.Empty <object>());
         EquipmentSlots[0].ResetButtonIfNotActive(___displayedActor);
     }
     if (CombatHUDEquipmentPanel.Instance != null)
     {
         CombatHUDEquipmentPanel.Instance.RefreshDisplayedEquipment(__instance.DisplayedActor);
     }
     ;
 }
Beispiel #5
0
 public static bool OverrideMultiTargetAssignment(CombatHUDWeaponPanel __instance, List <CombatHUDWeaponSlot> ___WeaponSlots)
 {
     try {
         SelectionStateFireMulti multi   = ActiveState as SelectionStateFireMulti;
         List <ICombatant>       targets = multi?.AllTargetedCombatants;
         if (targets.IsNullOrEmpty())
         {
             return(true);
         }
         foreach (CombatHUDWeaponSlot slot in ___WeaponSlots)
         {
             Weapon w      = slot?.DisplayedWeapon;
             int    target = FindBestTargetForWeapon(w, targets);
             if (target >= 0)
             {
                 SlotSetTargetIndexMethod.Invoke(slot, new object[] { multi.AssignWeaponToTarget(w, targets[target]), false });
             }
         }
         __instance.RefreshDisplayedWeapons();
         return(false);
     }                 catch (Exception ex) { return(Error(ex)); }
 }
Beispiel #6
0
        public static void Postfix(CombatHUDWeaponPanel __instance, List <CombatHUDWeaponSlot> ___WeaponSlots, List <Weapon> ___sortedWeaponsList)
        {
            foreach (var weapon in ___sortedWeaponsList)
            {
                LogDebug($"{weapon.UIName}: {weapon.RangeDescription}");
            }

            var hotkeyF1 = Input.GetKeyDown(KeyCode.F1);

            if (hotkeyF1)
            {
                switch (ballisticState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.Ballistic).Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.Ballistic).Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                ballisticState = !ballisticState;
            }

            var hotkeyF2 = Input.GetKeyDown(KeyCode.F2);

            if (hotkeyF2)
            {
                switch (energyState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.Energy).Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.Energy).Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                energyState = !energyState;
            }

            var hotkeyF3 = Input.GetKeyDown(KeyCode.F3);

            if (hotkeyF3)
            {
                switch (missileState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.Missile).Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.Missile).Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                missileState = !missileState;
            }

            var hotkeyF4 = Input.GetKeyDown(KeyCode.F4);

            if (hotkeyF4)
            {
                switch (supportState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.AntiPersonnel).Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.Category == WeaponCategory.AntiPersonnel).Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                supportState = !supportState;
            }

            var hotkeyF5 = Core.ModSettings.enableRangeSettings && Input.GetKeyDown(KeyCode.F5);

            if (hotkeyF5)
            {
                switch (closeRangeState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Close").Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Close").Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                closeRangeState = !closeRangeState;
            }

            var hotkeyF6 = Core.ModSettings.enableRangeSettings && Input.GetKeyDown(KeyCode.F6);

            if (hotkeyF6)
            {
                switch (standardRangeState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Standard").Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Standard").Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                standardRangeState = !standardRangeState;
            }

            var hotkeyF7 = Core.ModSettings.enableRangeSettings && Input.GetKeyDown(KeyCode.F7);

            if (hotkeyF7)
            {
                switch (longRangeState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Very Long").Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Very Long").Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                longRangeState = !longRangeState;
            }

            var hotkeyF8 = Core.ModSettings.enableRangeSettings && Input.GetKeyDown(KeyCode.F8);

            if (hotkeyF8)
            {
                switch (veryLongRangeState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Very Long").Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Very Long").Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                veryLongRangeState = !veryLongRangeState;
            }

            var hotkeyF9 = Core.ModSettings.enableRangeSettings && Input.GetKeyDown(KeyCode.F9);

            if (hotkeyF9)
            {
                switch (extremeRangeState)
                {
                case true:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Extreme").Do(w => w.DisableWeapon());
                    break;

                case false:
                    ___sortedWeaponsList.Where(w => w.RangeDescription == "Extreme").Do(w => w.EnableWeapon());
                    break;
                }

                __instance.RefreshDisplayedWeapons();
                extremeRangeState = !extremeRangeState;
            }
        }
Beispiel #7
0
 //public static bool Prepare() { return false; }
 public static void Postfix(CombatHUDWeaponPanel __instance)
 {
     __instance.ResetEquipmentState();
 }
Beispiel #8
0
 public static void ResetEquipmentState(this CombatHUDWeaponPanel panel)
 {
     weaponPanelState = true;
 }