private void SetupAbilityButtons()
    {
        AbilityButton[] abilityButtons = FindObjectsOfType <AbilityButton>();
        HackerLoadout   currentLoadout = hacker.GetHackerLoadout();

        foreach (AbilityButton abilityButton in abilityButtons)
        {
            switch (abilityButton.GetWhichAbility())
            {
            case "rig":
                HackerMod rigMod = currentLoadout.GetRigMod();
                abilityButton.SetupAbility(rigMod);
                break;

            case "neuralImplant":
                HackerMod neuralImplantMod = currentLoadout.GetNeuralImplantMod();
                abilityButton.SetupAbility(neuralImplantMod);
                break;

            case "uplink":
                HackerMod uplinkMod = currentLoadout.GetUplinkMod();
                abilityButton.SetupAbility(uplinkMod);
                break;
            }
        }
    }
    private void SetupHacker(string newHackerName, string newBio)
    {
        hackerName = newHackerName;
        bio        = newBio;

        hackerLoadout = CreateInstance <HackerLoadout>();
        hackerLoadout.SetupInitialLoadout(id);
    }
    public void RecreateHackerFromSave(SaveHacker saveHacker)
    {
        id         = saveHacker.id;
        hackerName = saveHacker.hackerName;
        bio        = saveHacker.bio;
        locked     = saveHacker.locked;

        hackerLoadout = CreateInstance <HackerLoadout>();
    }
    private bool IsItemEquipped()
    {
        switch (item.GetHackerOrRunner())
        {
        case Item.HackerRunner.Runner:
            Loadout   runnerLoadout = FindObjectOfType <PlayerData>().GetCurrentRunner().GetLoadout();
            RunnerMod currentMod    = item as RunnerMod;
            return(runnerLoadout.IsItemEquipped(currentMod));

        case Item.HackerRunner.Hacker:
            // TODO: FILL THIS SHIT IN FOR HACKER
            HackerLoadout hackerLoadout = FindObjectOfType <PlayerData>().GetCurrentHacker().GetHackerLoadout();
            return(hackerLoadout.IsItemEquipped(item));
        }
        return(false);
    }
    private void EnableOrDisableEquipButtonBasedOnSelection()
    {
        if (selectedItem == null)
        {
            runnerEquipButton.interactable = false;
            hackerEquipButton.interactable = false;
        }
        else
        {
            switch (selectedItem.GetHackerOrRunner())
            {
            case Item.HackerRunner.Runner:
                Loadout   runnerLoadout = FindObjectOfType <PlayerData>().GetCurrentRunner().GetLoadout();
                RunnerMod mod           = selectedItem as RunnerMod;
                if (runnerLoadout.IsItemEquipped(mod))
                {
                    runnerEquipButton.interactable = false;
                }
                else
                {
                    runnerEquipButton.interactable = true;
                }
                break;

            case Item.HackerRunner.Hacker:
                HackerLoadout hackerLoadout = FindObjectOfType <PlayerData>().GetCurrentHacker().GetHackerLoadout();
                if (hackerLoadout.IsItemEquipped(selectedItem))
                {
                    hackerEquipButton.interactable = false;
                }
                else
                {
                    hackerEquipButton.interactable = true;
                }
                break;
            }
        }
    }
    private void SetupActiveHackerSlots()
    {
        activeHackerSlotBtns = new List <LoadoutSlotBtn>();
        activeHackerSlotBtns.AddRange(hackerModSlots); // Always need these three

        HackerLoadout hackerLoadout = FindObjectOfType <PlayerData>().GetCurrentHacker().GetHackerLoadout();
        HackerMod     neuralImplant = hackerLoadout.GetNeuralImplantMod();

        switch (neuralImplant.GetCurrentLevelSlotCount())
        {
        case 1:
            wetware1SlotHolder.SetActive(true);
            wetware2SlotHolder.SetActive(false);
            wetware3SlotHolder.SetActive(false);
            activeHackerSlotBtns.AddRange(wetware1Slots);
            break;

        case 2:
            wetware1SlotHolder.SetActive(false);
            wetware2SlotHolder.SetActive(true);
            wetware3SlotHolder.SetActive(false);
            activeHackerSlotBtns.AddRange(wetware2Slots);
            break;

        case 3:
            wetware1SlotHolder.SetActive(false);
            wetware2SlotHolder.SetActive(false);
            wetware3SlotHolder.SetActive(true);
            activeHackerSlotBtns.AddRange(wetware3Slots);
            break;
        }

        HackerMod rig = hackerLoadout.GetRigMod();

        switch (rig.GetCurrentLevelSlotCount())
        {
        case 1:
            software1SlotHolder.SetActive(true);
            software2SlotHolder.SetActive(false);
            software3SlotHolder.SetActive(false);
            activeHackerSlotBtns.AddRange(software1Slots);
            break;

        case 2:
            software1SlotHolder.SetActive(false);
            software2SlotHolder.SetActive(true);
            software3SlotHolder.SetActive(false);
            activeHackerSlotBtns.AddRange(software2Slots);
            break;

        case 3:
            software1SlotHolder.SetActive(false);
            software2SlotHolder.SetActive(false);
            software3SlotHolder.SetActive(true);
            activeHackerSlotBtns.AddRange(software3Slots);
            break;
        }

        HackerMod uplink = hackerLoadout.GetUplinkMod();

        switch (uplink.GetCurrentLevelSlotCount())
        {
        case 1:
            chipset1SlotHolder.SetActive(true);
            chipset2SlotHolder.SetActive(false);
            chipset3SlotHolder.SetActive(false);
            activeHackerSlotBtns.AddRange(chipset1Slots);
            break;

        case 2:
            chipset1SlotHolder.SetActive(false);
            chipset2SlotHolder.SetActive(true);
            chipset3SlotHolder.SetActive(false);
            activeHackerSlotBtns.AddRange(chipset2Slots);
            break;

        case 3:
            chipset1SlotHolder.SetActive(false);
            chipset2SlotHolder.SetActive(false);
            chipset3SlotHolder.SetActive(true);
            activeHackerSlotBtns.AddRange(chipset3Slots);
            break;
        }

        foreach (LoadoutSlotBtn button in activeHackerSlotBtns)
        {
            button.SetupButton();
        }
    }
    public void EquipItem()
    {
        ClearWaitingForInputOnButtons();
        switch (hackerOrRunner)
        {
        case Item.HackerRunner.Runner:
            Loadout runnerLoadout = FindObjectOfType <PlayerData>().GetCurrentRunner().GetLoadout();

            if (selectedItem.GetItemType() == Item.ItemTypes.Arm || selectedItem.GetItemType() == Item.ItemTypes.Leg)
            {
                // Do we have an arm or leg slot selected? If so, equip to that one
                foreach (LoadoutSlotBtn loadoutSlot in runnerLoadoutSlotBtns)
                {
                    if (loadoutSlot.GetItemType() == selectedItem.GetItemType() && loadoutSlot.GetIsActive())
                    {
                        hubWorldSFX.PlayHubSoundEffect(HubWorldSFX.HubSoundeffect.EquipItem);
                        runnerLoadout.EquipItem(selectedItem as RunnerMod, loadoutSlot.GetLeftOrRight());
                        recentlyEquippedItem = true;
                    }
                }
                if (recentlyEquippedItem == false)
                {
                    // get and activate the appropriate buttons
                    foreach (LoadoutSlotBtn loadoutSlot in runnerLoadoutSlotBtns)
                    {
                        if (loadoutSlot.GetItemType() == selectedItem.GetItemType())
                        {
                            loadoutSlot.SetButtonToAskForInput();
                        }
                    }
                    waitingToEquip = true;
                    DisableAllOtherInputs();
                    // TODO: DISABLE OTHER INPUTS SOMEHOW
                }
            }
            else
            {
                hubWorldSFX.PlayHubSoundEffect(HubWorldSFX.HubSoundeffect.EquipItem);
                runnerLoadout.EquipItem(selectedItem as RunnerMod);
                recentlyEquippedItem = true;
            }
            break;

        case Item.HackerRunner.Hacker:
            HackerLoadout hackerLoadout = FindObjectOfType <PlayerData>().GetCurrentHacker().GetHackerLoadout();

            if (selectedItem.IsHackerMod())
            {
                hubWorldSFX.PlayHubSoundEffect(HubWorldSFX.HubSoundeffect.EquipItem);
                hackerLoadout.EquipItem(selectedItem as HackerMod);
                recentlyEquippedItem = true;
                SetupActiveHackerSlots();
            }
            else if (selectedItem.IsHackerChipset())
            {
                foreach (LoadoutSlotBtn loadoutSlot in activeHackerSlotBtns)
                {
                    if (loadoutSlot.GetItemType() == selectedItem.GetItemType() && loadoutSlot.GetIsActive())
                    {
                        hubWorldSFX.PlayHubSoundEffect(HubWorldSFX.HubSoundeffect.EquipItem);
                        hackerLoadout.EquipItem(selectedItem as HackerModChip, loadoutSlot.GetSlotNumber() - 1);
                        recentlyEquippedItem = true;
                    }
                }
                if (recentlyEquippedItem == false)
                {
                    // get and activate the appropriate buttons
                    foreach (LoadoutSlotBtn loadoutSlot in activeHackerSlotBtns)
                    {
                        if (loadoutSlot.GetItemType() == selectedItem.GetItemType())
                        {
                            loadoutSlot.SetButtonToAskForInput();
                        }
                    }
                    waitingToEquip = true;
                    DisableAllOtherInputs();
                    // TODO: DISABLE OTHER INPUTS SOMEHOW
                }
            }
            break;
        }
        SetupInventoryList();
    }