public void SetupInitialLoadout(int newHackerId)
{
hackerId = newHackerId;
switch (hackerId)
{
case 0:
rig = CreateInstance <HackerMod>();
rig.SetupMod("Basic Rig");
HackerModChip newSoftware = CreateInstance <HackerModChip>();
newSoftware.SetupChip("Cheap Ghost");
rig.InstallChip(newSoftware, 0);
neuralImplant = CreateInstance <HackerMod>();
neuralImplant.SetupMod("Basic Cranial Dock");
HackerModChip newWetware = CreateInstance <HackerModChip>();
newWetware.SetupChip("JuryRigged QwikThink");
neuralImplant.InstallChip(newWetware, 0);
uplink = CreateInstance <HackerMod>();
uplink.SetupMod("Basic Uplink");
HackerModChip newChipset = CreateInstance <HackerModChip>();
newChipset.SetupChip("Salvaged Router");
uplink.InstallChip(newChipset, 0);
break;
}
}
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 SetupModActiveAbility()
{
hackerModAbilityDescription.text = item.GetItemAbilityDescription();
HackerMod hackerMod = item as HackerMod;
string slotString = hackerMod.GetMaxSlotCount().ToString();
switch (hackerMod.GetItemType())
{
case Item.ItemTypes.NeuralImplant:
slotString += " Wetware";
break;
case Item.ItemTypes.Rig:
slotString += " Software";
break;
case Item.ItemTypes.Uplink:
slotString += " Chipsets";
break;
}
slotsField.text = slotString;
string path = "Icons/ActiveAbilityIcons/Ability" + hackerMod.GetActiveAbilityId().ToString();
hackerModAbilityIcon.sprite = Resources.Load <Sprite>(path);
string uses = " use";
if (hackerMod.GetActiveAbilityUses() > 1)
{
uses = " uses";
}
hackerModAbilityUseCount.text = hackerMod.GetActiveAbilityUses().ToString() + uses;
}
private void SetupActiveAbilityHolders()
{
UpgradeMenuActiveAbilityHolder[] abilities = { activeAbilityHolder1, activeAbilityHolder2, activeAbilityHolder3, activeAbilityHolder4, activeAbilityHolder5 };
List <UpgradeMenuActiveAbilityHolder> abilityHolders = new List <UpgradeMenuActiveAbilityHolder>();
abilityHolders.AddRange(abilities);
int counter = 0;
HackerMod hackerMod = item as HackerMod;
foreach (UpgradeMenuActiveAbilityHolder abilityHolder in abilityHolders)
{
counter++; // start off with #1
string abilityDescription = "";
int abilityUses = 0;
bool isCurrentLevel = false;
if (counter == hackerMod.GetCurrentItemLevel())
{
isCurrentLevel = true;
}
switch (counter)
{
case 1:
abilityDescription = hackerMod.GetLevelOneItemAbilityDescription();
abilityUses = hackerMod.GetLevel1AbilityUses();
break;
case 2:
abilityDescription = hackerMod.GetLevelTwoItemAbilityDescription();
abilityUses = hackerMod.GetLevel2AbilityUses();
break;
case 3:
abilityDescription = hackerMod.GetLevelThreeItemAbilityDescription();
abilityUses = hackerMod.GetLevel3AbilityUses();
break;
case 4:
abilityDescription = hackerMod.GetLevelFourItemAbilityDescription();
abilityUses = hackerMod.GetLevel4AbilityUses();
break;
case 5:
abilityDescription = hackerMod.GetLevelFiveItemAbilityDescription();
abilityUses = hackerMod.GetLevel5AbilityUses();
break;
}
string path = "Icons/ActiveAbilityIcons/Ability" + hackerMod.GetActiveAbilityId().ToString();
Sprite hackerAbilityIcon = Resources.Load <Sprite>(path);
abilityHolder.SetupAbilityHolder(hackerAbilityIcon, item.GetCurrentItemLevel(), counter, isCurrentLevel, abilityDescription, abilityUses);
}
}
public void UpgradeItem()
{
if (itemLevel < itemMaxLevel)
{
itemLevel++;
}
if (this.IsHackerMod())
{
HackerMod modToCheck = this as HackerMod;
modToCheck.FillExtraSlotsWithEmptyMods();
}
}
public string GenerateSlotDisplayString()
{
string displayString = "";
HackerMod mod = item as HackerMod;
if (item.GetItemLevel() == 1)
{
displayString += "<color=#FFFFFF>" + mod.GetLevel1SlotCount() + "</color>";
}
else
{
displayString += mod.GetLevel1SlotCount();
}
if (item.GetItemLevel() == 2)
{
displayString += " <color=#FFFFFF>" + mod.GetLevel2SlotCount() + "</color>";
}
else
{
displayString += " " + mod.GetLevel2SlotCount();
}
if (item.GetItemLevel() == 3)
{
displayString += " <color=#FFFFFF>" + mod.GetLevel3SlotCount() + "</color>";
}
else
{
displayString += " " + mod.GetLevel3SlotCount();
}
if (item.GetItemLevel() == 4)
{
displayString += " <color=#FFFFFF>" + mod.GetLevel4SlotCount() + "</color>";
}
else
{
displayString += " " + mod.GetLevel4SlotCount();
}
if (item.GetItemLevel() == 5)
{
displayString += " <color=#FFFFFF>" + mod.GetLevel5SlotCount() + "</color>";
}
else
{
displayString += " " + mod.GetLevel5SlotCount();
}
return(displayString);
}
public void SetupAbility(HackerMod newHackerMod)
{
hackerMod = newHackerMod;
maxAbilityUses = hackerMod.GetActiveAbilityUses();
currentAbilityUses = maxAbilityUses;
Button button = GetComponent <Button>();
disabledColor = button.colors.disabledColor;
normalColor = button.colors.normalColor;
SetAbilityIcon();
SetCurrentUseIcons();
}
public void SetupAbilityHolder(HackerMod hackerMod, AbilityButton newAbilityButton)
{
abilityButton = newAbilityButton;
mod = hackerMod;
abilityText.text = mod.GetItemAbilityDescription();
if (abilityButton.GetRemainingUses() == 1)
{
usesText.text = "1 use";
}
else
{
usesText.text = abilityButton.GetRemainingUses().ToString() + " uses";
}
abilityIcon.sprite = FindObjectOfType <AllHackAbilityIcons>().GetAbilityIconById(mod.GetActiveAbilityId());
}
public void EquipRecreatedItem(HackerMod hackerMod)
{
switch (hackerMod.GetItemType())
{
case Item.ItemTypes.Rig:
rig = hackerMod;
break;
case Item.ItemTypes.NeuralImplant:
neuralImplant = hackerMod;
break;
case Item.ItemTypes.Uplink:
uplink = hackerMod;
break;
}
}
private void SetupCardCarosel(Item item)
{
cardCarosel.ClearCardList();
List <int> cardIds = new List <int>();
switch (item.GetItemType())
{
case Item.ItemTypes.Arm:
case Item.ItemTypes.Exoskeleton:
case Item.ItemTypes.Head:
case Item.ItemTypes.Leg:
case Item.ItemTypes.Torso:
case Item.ItemTypes.Weapon:
RunnerMod runnerMod = item as RunnerMod;
cardIds.AddRange(runnerMod.GetCardIds());
abilityTypeText.text = "";
abilityDescriptionText.text = "";
break;
case Item.ItemTypes.NeuralImplant:
case Item.ItemTypes.Rig:
case Item.ItemTypes.Uplink:
HackerMod hackerMod = item as HackerMod;
abilityTypeText.text = "Active Ability:";
abilityDescriptionText.text = hackerMod.GetCurrentLevelAbilityDescription();
break;
case Item.ItemTypes.Chipset:
case Item.ItemTypes.Software:
case Item.ItemTypes.Wetware:
HackerModChip hackerModChip = item as HackerModChip;
cardIds.AddRange(hackerModChip.GetCardIds());
abilityTypeText.text = "Passive Ability:";
abilityDescriptionText.text = hackerModChip.GetCurrentLevelAbilityString();
break;
}
foreach (int id in cardIds)
{
Card card = Resources.Load <Card>("CardPrefabs/Player/Card" + id);
cardCarosel.AddCardToList(card);
}
cardCarosel.GenerateListItems();
}
public void EquipItem(HackerMod hackerMod)
{
Debug.Log("Hackermod stuff");
List <HackerModChip> equippedChips = new List <HackerModChip>();
switch (hackerMod.GetItemType())
{
case Item.ItemTypes.NeuralImplant:
equippedChips = neuralImplant.GetAttachedChips();
if (equippedChips.Count < hackerMod.GetCurrentLevelSlotCount())
{
equippedChips.AddRange(FillEmptySlotsWithInventoryItems(Item.ItemTypes.Wetware, hackerMod.GetCurrentLevelSlotCount() - equippedChips.Count));
}
neuralImplant = hackerMod;
break;
case Item.ItemTypes.Rig:
equippedChips = rig.GetAttachedChips();
if (equippedChips.Count < hackerMod.GetCurrentLevelSlotCount())
{
equippedChips.AddRange(FillEmptySlotsWithInventoryItems(Item.ItemTypes.Software, hackerMod.GetCurrentLevelSlotCount() - equippedChips.Count));
}
rig = hackerMod;
break;
case Item.ItemTypes.Uplink:
equippedChips = uplink.GetAttachedChips();
if (equippedChips.Count < hackerMod.GetCurrentLevelSlotCount())
{
equippedChips.AddRange(FillEmptySlotsWithInventoryItems(Item.ItemTypes.Chipset, hackerMod.GetCurrentLevelSlotCount() - equippedChips.Count));
}
uplink = hackerMod;
break;
}
for (int i = 0; i < hackerMod.GetCurrentLevelSlotCount(); i++)
{
hackerMod.InstallChip(equippedChips[i], i);
}
}
public void OpenMenu()
{
gameObject.SetActive(true);
FindObjectOfType <CheckClickController>().SetOverlayState();
AbilityButton[] abilityButtons = FindObjectsOfType <AbilityButton>();
foreach (AbilityButton abilityButton in abilityButtons)
{
HackerMod hackerMod = abilityButton.GetHackerMod();
switch (hackerMod.GetItemType())
{
case Item.ItemTypes.NeuralImplant:
neuralImplantAbilityHolder.SetupAbilityHolder(hackerMod, abilityButton);
break;
case Item.ItemTypes.Rig:
rigAbilityHolder.SetupAbilityHolder(hackerMod, abilityButton);
break;
case Item.ItemTypes.Uplink:
uplinkAbilityHolder.SetupAbilityHolder(hackerMod, abilityButton);
break;
}
}
}
private void SelectEquippedItemInList()
{
// To highlight currently equipped item, first we see if there is only one filter...
if (currentFilters.Count == 1)
{
PlayerData playerData = FindObjectOfType <PlayerData>();
switch (hackerOrRunner)
{
// Then we find if there are any active buttons and get the leftOrRight and itemType from them
case Item.HackerRunner.Runner:
Loadout.LeftOrRight leftOrRight;
Item.ItemTypes itemType;
foreach (LoadoutSlotBtn button in runnerLoadoutSlotBtns)
{
if (button.GetIsActive())
{
itemType = button.GetItemType();
leftOrRight = button.GetLeftOrRight();
RunnerMod equippedMod = playerData.GetCurrentRunner().GetLoadout().GetEquippedModByItemType(itemType, leftOrRight);
currentInventoryList.SelectParticularItem(equippedMod);
}
}
break;
case Item.HackerRunner.Hacker:
foreach (LoadoutSlotBtn button in activeHackerSlotBtns)
{
if (button.GetIsActive())
{
// do for mod
itemType = button.GetItemType();
if (button.GetItemType() == Item.ItemTypes.NeuralImplant || button.GetItemType() == Item.ItemTypes.Rig || button.GetItemType() == Item.ItemTypes.Uplink)
{
HackerMod equippedMod = playerData.GetCurrentHacker().GetHackerLoadout().GetEquippedModByItemType(itemType);
currentInventoryList.SelectParticularItem(equippedMod);
}
else
{
// do for install
int slotNumber = button.GetSlotNumber();
HackerModChip hackerModChip = playerData.GetCurrentHacker().GetHackerLoadout().GetEquippedInstallByItemTypeAndSlotNumber(itemType, slotNumber);
currentInventoryList.SelectParticularItem(hackerModChip);
}
}
}
break;
}
}
else if (recentlyEquippedItem == true)
{
recentlyEquippedItem = false;
switch (hackerOrRunner)
{
case Item.HackerRunner.Runner:
currentInventoryList.SelectParticularItem(selectedItem);
break;
case Item.HackerRunner.Hacker:
currentInventoryList.SelectParticularItem(selectedItem);
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 LoadPlayer(int saveSlotToLoad)
{
SaveObject saveObject = SaveSystem.LoadPlayerData(saveSlotToLoad);
// Recreate Owned Items
ownedItems = new List <Item>();
List <SaveItem> deserializedSaveItems = JsonConvert.DeserializeObject <List <SaveItem> >(saveObject.items);
foreach (SaveItem saveItem in deserializedSaveItems)
{
if (saveItem.hackerOrRunner == (int)Item.HackerRunner.Hacker)
{
// Hacker Items
if (saveItem.itemType == (int)Item.ItemTypes.Rig || saveItem.itemType == (int)Item.ItemTypes.NeuralImplant || saveItem.itemType == (int)Item.ItemTypes.Uplink)
{
HackerMod newHackerMod = ScriptableObject.CreateInstance <HackerMod>();
newHackerMod.RecreateSavedHackerMod(saveItem);
ownedItems.Add(newHackerMod);
}
else
{
HackerModChip newHackerModChip = ScriptableObject.CreateInstance <HackerModChip>();
newHackerModChip.RecreateSavedHackerModChip(saveItem);
ownedItems.Add(newHackerModChip);
}
}
else if (saveItem.hackerOrRunner == (int)Item.HackerRunner.Runner)
{
// Create Runner Items
RunnerMod newRunnerMod = ScriptableObject.CreateInstance <RunnerMod>();
newRunnerMod.RecreateSavedRunnerMod(saveItem);
ownedItems.Add(newRunnerMod);
}
}
// Create Runners
List <SaveRunner> saveRunners = JsonConvert.DeserializeObject <List <SaveRunner> >(saveObject.runners);
ownedRunners = new List <CharacterData>();
foreach (SaveRunner saveRunner in saveRunners)
{
CharacterData newRunner = ScriptableObject.CreateInstance <CharacterData>();
newRunner.RecreateRunnerFromSaveData(saveRunner);
Loadout runnerLoadout = newRunner.GetLoadout();
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.headItemId));
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.torsoModId));
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.exoskeletonModId));
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.leftArmModId), Loadout.LeftOrRight.Left);
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.rightArmModId), Loadout.LeftOrRight.Right);
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.leftLegModId), Loadout.LeftOrRight.Left);
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.rightLegModId), Loadout.LeftOrRight.Right);
runnerLoadout.EquipItem((RunnerMod)GetLoadedItemById(saveRunner.weaponModId));
ownedRunners.Add(newRunner);
if (newRunner.GetRunnerId() == saveObject.currentRunner)
{
currentRunner = newRunner;
}
}
List <SaveHacker> saveHackers = JsonConvert.DeserializeObject <List <SaveHacker> >(saveObject.hackers);
ownedHackers = new List <HackerData>();
foreach (SaveHacker saveHacker in saveHackers)
{
HackerData newHacker = ScriptableObject.CreateInstance <HackerData>();
newHacker.RecreateHackerFromSave(saveHacker);
if (!newHacker.GetIsLocked())
{
HackerMod newRigMod = (HackerMod)GetLoadedItemById(saveHacker.rigModId);
if (saveHacker.rigSoftwareId1 != -1)
{
newRigMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.rigSoftwareId1), 0);
}
if (saveHacker.rigSoftwareId2 != -1)
{
newRigMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.rigSoftwareId2), 1);
}
if (saveHacker.rigSoftwareId3 != -1)
{
newRigMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.rigSoftwareId3), 2);
}
newHacker.GetHackerLoadout().EquipRecreatedItem(newRigMod);
HackerMod newNeuralImplantMod = (HackerMod)GetLoadedItemById(saveHacker.neuralImplantId);
if (saveHacker.neuralWetwareId1 != -1)
{
newNeuralImplantMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.neuralWetwareId1), 0);
}
if (saveHacker.neuralWetwareId2 != -1)
{
newNeuralImplantMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.neuralWetwareId2), 1);
}
if (saveHacker.neuralWetwareId3 != -1)
{
newNeuralImplantMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.neuralWetwareId3), 2);
}
newHacker.GetHackerLoadout().EquipRecreatedItem(newNeuralImplantMod);
HackerMod newUplinkMod = (HackerMod)GetLoadedItemById(saveHacker.uplinkId);
if (saveHacker.uplinkChipsetId1 != -1)
{
newUplinkMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.uplinkChipsetId1), 0);
}
if (saveHacker.uplinkChipsetId2 != -1)
{
newUplinkMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.uplinkChipsetId2), 1);
}
if (saveHacker.uplinkChipsetId3 != -1)
{
newUplinkMod.InstallChip((HackerModChip)GetLoadedItemById(saveHacker.uplinkChipsetId3), 2);
}
newHacker.GetHackerLoadout().EquipRecreatedItem(newUplinkMod);
}
ownedHackers.Add(newHacker);
if (newHacker.GetHackerId() == saveObject.currentHacker)
{
currentHacker = newHacker;
}
}
List <SaveJob> saveJobs = JsonConvert.DeserializeObject <List <SaveJob> >(saveObject.jobOptions);
currentJobOptions = new List <Job>();
foreach (SaveJob saveJob in saveJobs)
{
Job newJob = ScriptableObject.CreateInstance <Job>();
newJob.LoadJobFromSave(saveJob);
currentJobOptions.Add(newJob);
}
// General Player Data
currentCredits = saveObject.playerCredits;
generatedItemId = saveObject.currentItemId;
saveSlot = saveObject.saveSlot;
// Shop Stuff
currentShopType = (ShopMenu.ShopForSaleType)saveObject.currentShopType;
previousShopTypes = new List <ShopMenu.ShopForSaleType>();
List <int> shopTypeIds = JsonConvert.DeserializeObject <List <int> >(saveObject.previousShopTypes);
foreach (int shopTypeId in shopTypeIds)
{
previousShopTypes.Add((ShopMenu.ShopForSaleType)shopTypeId);
}
List <SaveItem> savedShopItems = JsonConvert.DeserializeObject <List <SaveItem> >(saveObject.itemsForSale);
itemsForSale = new List <Item>();
foreach (SaveItem saveItem in savedShopItems)
{
if (saveItem.hackerOrRunner == (int)Item.HackerRunner.Hacker)
{
// Hacker Items
if (saveItem.itemType == (int)Item.ItemTypes.Rig || saveItem.itemType == (int)Item.ItemTypes.NeuralImplant || saveItem.itemType == (int)Item.ItemTypes.Uplink)
{
HackerMod newHackerMod = ScriptableObject.CreateInstance <HackerMod>();
newHackerMod.RecreateSavedHackerMod(saveItem);
itemsForSale.Add(newHackerMod);
}
else
{
HackerModChip newHackerModChip = ScriptableObject.CreateInstance <HackerModChip>();
newHackerModChip.RecreateSavedHackerModChip(saveItem);
itemsForSale.Add(newHackerModChip);
}
}
else if (saveItem.hackerOrRunner == (int)Item.HackerRunner.Runner)
{
// Create Runner Items
RunnerMod newRunnerMod = ScriptableObject.CreateInstance <RunnerMod>();
newRunnerMod.RecreateSavedRunnerMod(saveItem);
itemsForSale.Add(newRunnerMod);
}
}
isPlayerLoaded = true;
}
private void AttemptToCreateShopItems(List <string> itemNames)
{
// TODO: DO OBJECTS NEED TO BE DESTROYED???
List <Item> shopItems = new List <Item>();
foreach (string itemName in itemNames)
{
RunnerMod createAsRunnerMod = ScriptableObject.CreateInstance <RunnerMod>();
bool success = createAsRunnerMod.SetupMod(itemName);
if (!success)
{
// Failed to create as a runner mod, try a hacker mod...
HackerMod createAsHackerMod = ScriptableObject.CreateInstance <HackerMod>();
success = createAsHackerMod.SetupMod(itemName);
if (!success)
{
// Failed to create as a hacker mod, try a hacker install...
HackerModChip createAsHackerInstall = ScriptableObject.CreateInstance <HackerModChip>();
success = createAsHackerInstall.SetupChip(itemName);
if (success)
{
// TODO: CREATE EXTRA COPIES TO ADD TO LIST
shopItems.Add(createAsHackerInstall);
}
}
else
{
shopItems.Add(createAsHackerMod);
}
}
else
{
bool addToShop = true;
if (createAsRunnerMod.GetItemType() == Item.ItemTypes.Arm || createAsRunnerMod.GetItemType() == Item.ItemTypes.Leg)
{
// If arm or leg, we need to count them
List <Item> sameItems = ownedItems.FindAll(curentItem => createAsRunnerMod.GetItemName() == curentItem.GetItemName());
switch (sameItems.Count)
{
case 0:
RunnerMod secondCopy = ScriptableObject.CreateInstance <RunnerMod>();
secondCopy.SetupMod(itemName);
shopItems.Add(secondCopy);
break;
case 1:
break;
case 2:
addToShop = false;
break;
}
}
if (addToShop)
{
shopItems.Add(createAsRunnerMod);
}
}
}
itemsForSale = shopItems;
}
