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 EquipItem(RunnerMod newMod, LeftOrRight leftOrRight)
{
switch (newMod.GetItemType())
{
case Item.ItemTypes.Arm:
if (leftOrRight == LeftOrRight.Left)
{
leftArm = newMod;
}
else if (leftOrRight == LeftOrRight.Right)
{
rightArm = newMod;
}
break;
case Item.ItemTypes.Leg:
if (leftOrRight == LeftOrRight.Left)
{
leftLeg = newMod;
}
else if (leftOrRight == LeftOrRight.Right)
{
rightLeg = newMod;
}
break;
}
}
public void EquipItem(RunnerMod newMod)
{
switch (newMod.GetItemType())
{
case Item.ItemTypes.Arm:
// TODO: DO THIS DIFFERENTLY IN AN OVERLOADED FUNCTION
break;
case Item.ItemTypes.Exoskeleton:
exoskeletonMod = newMod;
break;
case Item.ItemTypes.Head:
headMod = newMod;
break;
case Item.ItemTypes.Leg:
// TODO: DO THIS DIFFERENTLY IN AN OVERLOADED FUNCTION WITH LEFT/RIGHT
break;
case Item.ItemTypes.Torso:
torsoMod = newMod;
break;
case Item.ItemTypes.Weapon:
weapon = newMod;
break;
}
}
public void SetupInitialLoadout(int newRunnerId)
{
runnerId = newRunnerId;
switch (runnerId)
{
case 0:
headMod = CreateInstance <RunnerMod>();
headMod.SetupMod("Human Eyes");
torsoMod = CreateInstance <RunnerMod>();
torsoMod.SetupMod("Unmodded Torso");
exoskeletonMod = CreateInstance <RunnerMod>();
exoskeletonMod.SetupMod("Human Skin");
leftArm = CreateInstance <RunnerMod>();
leftArm.SetupMod("Unmodded Arm");
rightArm = CreateInstance <RunnerMod>();
rightArm.SetupMod("Unmodded Arm");
leftLeg = CreateInstance <RunnerMod>();
leftLeg.SetupMod("Unmodded Leg");
rightLeg = CreateInstance <RunnerMod>();
rightLeg.SetupMod("Unmodded Leg");
weapon = CreateInstance <RunnerMod>();
weapon.SetupMod("Spanner");
break;
}
}
public bool IsItemEquipped(RunnerMod modToCheck)
{
RunnerMod[] runnerMods = GetAllMods();
foreach (RunnerMod mod in runnerMods)
{
if (mod.GetInstanceID() == modToCheck.GetInstanceID())
{
return(true);
}
}
return(false);
}
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 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 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 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 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;
}
private RunnerMod[] GetAllMods()
{
RunnerMod[] allMods = new RunnerMod[] { headMod, torsoMod, exoskeletonMod, leftArm, rightArm, leftLeg, rightLeg, weapon };
return(allMods);
}
