private void SetupCardCarosels()
{
currentCardCarosel.ClearCardLists();
currentCardCarosel.InitializeToggle();
currentCardCarosel.SetHackerOrRunner(item.GetHackerOrRunner());
if (item.GetHackerOrRunner() == Item.HackerRunner.Runner)
{
RunnerMod runnerMod = item as RunnerMod;
AddCardIdsToCaroselHolder(runnerMod.GetLevelOneCardIds(), 1);
AddCardIdsToCaroselHolder(runnerMod.GetLevelTwoCardIds(), 2);
AddCardIdsToCaroselHolder(runnerMod.GetLevelThreeCardIds(), 3);
AddCardIdsToCaroselHolder(runnerMod.GetLevelFourCardIds(), 4);
AddCardIdsToCaroselHolder(runnerMod.GetLevelFiveCardIds(), 5);
}
else
{
//HackerModChip hackerInstall = item as HackerModChip;
//lvl1CardIds.AddRange(hackerInstall.GetCardIds());
HackerModChip hackerInstall = item as HackerModChip;
AddCardIdsToCaroselHolder(hackerInstall.GetLevelOneCardIds(), 1);
AddCardIdsToCaroselHolder(hackerInstall.GetLevelTwoCardIds(), 2);
AddCardIdsToCaroselHolder(hackerInstall.GetLevelThreeCardIds(), 3);
}
currentCardCarosel.GenerateListItems(item.GetCurrentItemLevel());
}
private void SetupCardCarosel(Item item)
{
currentCardCarosel.ClearCardList();
List <int> cardIds = new List <int>();
switch (hackerOrRunner)
{
case Item.HackerRunner.Runner:
RunnerMod runnerMod = item as RunnerMod;
cardIds.AddRange(runnerMod.GetCardIds());
break;
case Item.HackerRunner.Hacker:
if (item.IsHackerChipset())
{
HackerModChip hackerModChip = item as HackerModChip;
cardIds.AddRange(hackerModChip.GetCardIds());
}
break;
}
foreach (int id in cardIds)
{
Card card = Resources.Load <Card>("CardPrefabs/Player/Card" + id);
currentCardCarosel.AddCardToList(card);
}
currentCardCarosel.GenerateListItems();
}
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 List <HackerModChip> AddItemsToInventoryToFillEmptySlots(Item.ItemTypes chipType, int amountToCreate)
{
List <HackerModChip> installs = new List <HackerModChip>();
PlayerData playerData = FindObjectOfType <PlayerData>();
for (int i = 0; i < amountToCreate; i++)
{
switch (chipType)
{
case Item.ItemTypes.Wetware:
HackerModChip newWetware = CreateInstance <HackerModChip>();
newWetware.SetupChip("JuryRigged QwikThink");
installs.Add(newWetware);
playerData.AddToOwnedItems(newWetware);
break;
case Item.ItemTypes.Software:
HackerModChip newSoftware = CreateInstance <HackerModChip>();
newSoftware.SetupChip("Cheap Ghost");
installs.Add(newSoftware);
playerData.AddToOwnedItems(newSoftware);
break;
case Item.ItemTypes.Chipset:
HackerModChip newChipset = CreateInstance <HackerModChip>();
newChipset.SetupChip("Salvaged Router");
installs.Add(newChipset);
playerData.AddToOwnedItems(newChipset);
break;
}
}
return(installs);
}
public void InstallChip(HackerModChip newHackerModChip, int slot)
{
FillExtraSlotsWithEmptyMods();
Debug.Log(newHackerModChip.GetItemType().ToString());
// check we're installing the right kind of chip in the mod
ItemTypes newChipType = newHackerModChip.GetItemType();
switch (itemType)
{
case ItemTypes.Rig:
if (newChipType != ItemTypes.Software)
{
Debug.LogError("Can only install software in Rig");
}
break;
case ItemTypes.NeuralImplant:
if (newChipType != ItemTypes.Wetware)
{
Debug.LogError("Can only install wetware in Neural Implant");
}
break;
case ItemTypes.Uplink:
if (newChipType != ItemTypes.Chipset)
{
Debug.LogError("Can only install chipsets in Uplink");
}
break;
}
modChips[slot] = newHackerModChip;
}
private HackerModChip CreateEmptyInstall()
{
HackerModChip emptyInstall = CreateInstance <HackerModChip>();
emptyInstall.SetupChip("Empty");
FindObjectOfType <PlayerData>().GetItemId();
return(emptyInstall);
}
public void EquipItem(HackerModChip newModChip, int slotNumber)
{
switch (newModChip.GetItemType())
{
case Item.ItemTypes.Chipset:
GetUplinkMod().InstallChip(newModChip, slotNumber);
break;
case Item.ItemTypes.Software:
GetRigMod().InstallChip(newModChip, slotNumber);
break;
case Item.ItemTypes.Wetware:
GetNeuralImplantMod().InstallChip(newModChip, slotNumber);
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();
}
private void SetupCardCarosel()
{
currentCardCarosel.ClearCardList();
currentCardCarosel.InitializeToggle();
List <int> cardIds = new List <int>();
if (item.GetHackerOrRunner() == Item.HackerRunner.Runner)
{
RunnerMod runnerMod = item as RunnerMod;
cardIds.AddRange(runnerMod.GetCardIds());
}
else
{
HackerModChip hackerInstall = item as HackerModChip;
cardIds.AddRange(hackerInstall.GetCardIds());
}
foreach (int id in cardIds)
{
Card card = Resources.Load <Card>("CardPrefabs/Player/Card" + id);
currentCardCarosel.AddCardToList(card);
}
currentCardCarosel.GenerateListItems();
}
private void SetupHackerMenu()
{
runnerContext.SetActive(false);
hackerContext.SetActive(true);
Item.ItemTypes[] modTypes = { Item.ItemTypes.NeuralImplant, Item.ItemTypes.Rig, Item.ItemTypes.Uplink };
List <Item.ItemTypes> modTypesList = new List <Item.ItemTypes>();
modTypesList.AddRange(modTypes);
if (modTypesList.Contains(item.GetItemType()))
{
// Is a mod
hackerModContext.SetActive(true);
hackerInstallContext.SetActive(false);
switch (context)
{
case ItemDetailsMenu.ItemDetailMenuContextType.Inventory:
hackerModShopContext.SetActive(false);
break;
case ItemDetailsMenu.ItemDetailMenuContextType.Loadout:
hackerModShopContext.SetActive(false);
break;
case ItemDetailsMenu.ItemDetailMenuContextType.Shop:
if (shopMenu.GetOpenShopTab() == "upgrade")
{
hackerModShopContext.SetActive(true);
SetupUpgradeButtons(hackerModUpgradeButtons);
}
else
{
hackerModShopContext.SetActive(false);
}
break;
}
switch (item.GetItemType())
{
case Item.ItemTypes.NeuralImplant:
hackerModChipsetSlots.gameObject.SetActive(false);
hackerModSoftwareSlots.gameObject.SetActive(false);
hackerModWetwareSlots.gameObject.SetActive(true);
break;
case Item.ItemTypes.Rig:
hackerModChipsetSlots.gameObject.SetActive(false);
hackerModSoftwareSlots.gameObject.SetActive(true);
hackerModWetwareSlots.gameObject.SetActive(false);
break;
case Item.ItemTypes.Uplink:
hackerModChipsetSlots.gameObject.SetActive(true);
hackerModSoftwareSlots.gameObject.SetActive(false);
hackerModWetwareSlots.gameObject.SetActive(false);
break;
}
slotCountText.text = GenerateSlotDisplayString();
SetupActiveAbilityHolders();
}
else
{
// Is an install
currentCardCarosel = hackerInstallCardCarosel;
switch (context)
{
case ItemDetailsMenu.ItemDetailMenuContextType.Inventory:
hackerInstallShopContext.SetActive(false);
break;
case ItemDetailsMenu.ItemDetailMenuContextType.Loadout:
hackerInstallShopContext.SetActive(false);
break;
case ItemDetailsMenu.ItemDetailMenuContextType.Shop:
if (shopMenu.GetOpenShopTab() == "upgrade")
{
hackerInstallShopContext.SetActive(true);
SetupUpgradeButtons(hackerInstallUpgradeButtons);
}
else
{
hackerInstallShopContext.SetActive(false);
}
break;
}
hackerInstallContext.SetActive(true);
hackerModContext.SetActive(false);
SetupCardCarosels();
SetupLevelMarkers();
HackerModChip chip = item as HackerModChip;
hackerPassiveAbilityText.text = chip.GetPassiveAbilityStringByLevel(item.GetItemLevel());
}
}
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;
}
}
}
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;
}
