Files

696 lines
28 KiB
C#
Raw Permalink Normal View History

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System;
public class savePlayerInventoryInfo : saveGameInfo
{
[Space]
[Header ("Other Options")]
[Space]
public bool ignoreAssignLoadedInventoryIfEmpty;
[Space]
[Header ("Debug")]
[Space]
public List<inventoryListElement> persistanceInfoList;
[Space]
[Header ("Components")]
[Space]
public inventoryManagerInfo mainInventoryManager;
bool lastGameSavedOnHomeMenuValue;
public override void saveGame (int saveNumber, int playerID, string currentSaveDataPath, bool showDebugInfo, bool savingGameToChangeScene)
{
saveGameContent (saveNumber, playerID, currentSaveDataPath, showDebugInfo, savingGameToChangeScene);
}
public override void loadGame (int saveNumberToLoad, int playerID, string currentSaveDataPath, bool showDebugInfo)
{
loadGameContent (saveNumberToLoad, playerID, currentSaveDataPath, showDebugInfo);
}
public override void saveGameFromEditor (int saveNumber, int playerID, string currentSaveDataPath, bool showDebugInfo)
{
saveGameContentFromEditor (saveNumber, playerID, currentSaveDataPath, showDebugInfo);
}
public override void initializeValuesOnComponent ()
{
initializeValues ();
}
public void saveGameContent (int currentSaveNumber, int playerID, string currentSaveDataPath, bool showDebugInfo, bool savingGameToChangeScene)
{
if (mainInventoryManager == null) {
return;
}
if (!mainInventoryManager.isSaveCurrentPlayerInventoryToSaveFileActive ()) {
return;
}
if (showDebugInfo) {
print ("\n\n");
print ("Saving player inventory");
}
bool saveLocated = false;
bool playerLocated = false;
int saveSlotIndex = -1;
int listIndex = -1;
BinaryFormatter bf = new BinaryFormatter ();
FileStream file;
persistanceInventoryListByPlayerInfo inventoryListToSave = getPersistanceList (playerID, showDebugInfo);
persistanceInventoryListBySaveSlotInfo newPersistanceInventoryListBySaveSlotInfo = new persistanceInventoryListBySaveSlotInfo ();
List<persistanceInventoryListBySaveSlotInfo> infoListToSave = new List<persistanceInventoryListBySaveSlotInfo> ();
if (File.Exists (currentSaveDataPath)) {
bf = new BinaryFormatter ();
file = File.Open (currentSaveDataPath, FileMode.Open);
object currentData = bf.Deserialize (file);
infoListToSave = currentData as List<persistanceInventoryListBySaveSlotInfo>;
file.Close ();
}
if (showDebugInfo) {
print ("Number of save list for player inventory " + infoListToSave.Count);
}
int infoListToSaveCount = infoListToSave.Count;
for (int j = 0; j < infoListToSaveCount; j++) {
if (saveSlotIndex == -1) {
persistanceInventoryListBySaveSlotInfo currentSlot = infoListToSave [j];
if (currentSlot.saveNumber == currentSaveNumber) {
newPersistanceInventoryListBySaveSlotInfo = currentSlot;
saveLocated = true;
saveSlotIndex = j;
}
}
}
if (saveLocated) {
int playerInventoryListCount = newPersistanceInventoryListBySaveSlotInfo.playerInventoryList.Count;
int playerIDToSearch = inventoryListToSave.playerID;
for (int j = 0; j < playerInventoryListCount; j++) {
if (listIndex == -1) {
if (newPersistanceInventoryListBySaveSlotInfo.playerInventoryList [j].playerID == playerIDToSearch) {
playerLocated = true;
listIndex = j;
}
}
}
}
if (showDebugInfo) {
print ("\n\n");
print ("EXTRA INFO\n");
print ("PLAYER INVENTORY");
print ("Number of objects: " + inventoryListToSave.inventoryObjectList.Count);
print ("Current Save Number " + currentSaveNumber);
print ("Save Located " + saveLocated);
print ("Player Located " + playerLocated);
print ("Player ID " + inventoryListToSave.playerID);
print ("Save List Index " + listIndex);
}
//if the save is located, check if the player id exists
if (saveLocated) {
//if player id exists, overwrite it
if (playerLocated) {
// infoListToSave [saveSlotIndex].playerInventoryList [listIndex].inventoryObjectList = inventoryListToSave.inventoryObjectList;
infoListToSave [saveSlotIndex].playerInventoryList [listIndex] = inventoryListToSave;
} else {
infoListToSave [saveSlotIndex].playerInventoryList.Add (inventoryListToSave);
}
} else {
newPersistanceInventoryListBySaveSlotInfo.saveNumber = currentSaveNumber;
newPersistanceInventoryListBySaveSlotInfo.gameSavedOnHomeMenu = gameSavedOnHomeMenu;
newPersistanceInventoryListBySaveSlotInfo.playerInventoryList.Add (inventoryListToSave);
infoListToSave.Add (newPersistanceInventoryListBySaveSlotInfo);
if (showDebugInfo) {
if (gameSavedOnHomeMenu) {
print ("Game saved on home menu");
print ("\n\n");
}
}
}
bf = new BinaryFormatter ();
file = File.Open (currentSaveDataPath, FileMode.OpenOrCreate);
bf.Serialize (file, infoListToSave);
file.Close ();
}
public void loadGameContent (int saveNumberToLoad, int playerID, string currentSaveDataPath, bool showDebugInfo)
{
if (mainInventoryManager == null) {
return;
}
if (!mainInventoryManager.isLoadCurrentPlayerInventoryFromSaveFileActive ()) {
initializeValues ();
return;
}
if (showDebugInfo) {
print ("\n\n");
print ("Loading player inventory with PLAYER ID " + playerID + " and saveNumberToLoad " + saveNumberToLoad);
}
//need to store and check the current slot saved and the player which is saving, to get that concrete info
persistanceInfoList = new List<inventoryListElement> ();
List<persistanceInventoryListBySaveSlotInfo> infoListToLoad = new List<persistanceInventoryListBySaveSlotInfo> ();
if (File.Exists (currentSaveDataPath)) {
BinaryFormatter bf = new BinaryFormatter ();
FileStream file = File.Open (currentSaveDataPath, FileMode.Open);
object currentData = bf.Deserialize (file);
infoListToLoad = currentData as List<persistanceInventoryListBySaveSlotInfo>;
file.Close ();
if (showDebugInfo) {
print ("Save File located " + currentSaveDataPath);
print ("\n\n");
}
} else {
if (showDebugInfo) {
print ("Save File not located " + currentSaveDataPath);
print ("\n\n");
}
}
lastGameSavedOnHomeMenuValue = false;
if (saveNumberToLoad > -1) {
if (showDebugInfo) {
print (infoListToLoad.Count);
}
bool removeSaveInfo = false;
persistanceInventoryListBySaveSlotInfo newPersistanceInventoryListBySaveSlotInfo = new persistanceInventoryListBySaveSlotInfo ();
int infoListToLoadCount = infoListToLoad.Count;
bool slotLocated = false;
for (int j = 0; j < infoListToLoadCount; j++) {
if (!slotLocated) {
persistanceInventoryListBySaveSlotInfo currentSlot = infoListToLoad [j];
bool checkSlot = false;
// if (ignoreSaveNumberOnSaveLoadInfo) {
// checkSlot = true;
// }
if (saveNumberToIgnoreSaveLoadInfo == saveNumberToLoad && saveNumberToIgnoreSaveLoadInfo > -1 && currentSlot.gameSavedOnHomeMenu) {
removeSaveInfo = true;
checkSlot = true;
}
if (currentSlot.saveNumber == saveNumberToLoad) {
checkSlot = true;
}
if (checkSlot) {
newPersistanceInventoryListBySaveSlotInfo = currentSlot;
slotLocated = true;
}
}
}
//print ("number " + newPersistanceInventoryListBySaveSlotInfo.playerInventoryList.Count);
int listIndex = -1;
int playerInventoryListCount = newPersistanceInventoryListBySaveSlotInfo.playerInventoryList.Count;
for (int j = 0; j < playerInventoryListCount; j++) {
// print (newPersistanceInventoryListBySaveSlotInfo.playerInventoryList [j].playerID + " " +
// newPersistanceInventoryListBySaveSlotInfo.playerInventoryList [j].inventorySlotAmount);
//
if (listIndex == -1) {
bool checkSlot = false;
// if (ignorePlayerIDOnSaveLoadInfo) {
// checkSlot = true;
// }
if (saveNumberToIgnoreSaveLoadInfo == saveNumberToLoad && saveNumberToIgnoreSaveLoadInfo > -1) {
checkSlot = true;
}
if (newPersistanceInventoryListBySaveSlotInfo.playerInventoryList [j].playerID == playerID) {
checkSlot = true;
}
if (checkSlot) {
listIndex = j;
}
}
}
//print ("index " + listIndex);
if (listIndex > -1) {
lastGameSavedOnHomeMenuValue = newPersistanceInventoryListBySaveSlotInfo.gameSavedOnHomeMenu;
persistanceInventoryListByPlayerInfo playerInventoryListToLoad = newPersistanceInventoryListBySaveSlotInfo.playerInventoryList [listIndex];
int inventoryObjectListCount = playerInventoryListToLoad.inventoryObjectList.Count;
for (int j = 0; j < inventoryObjectListCount; j++) {
inventoryListElement newInventoryListElement = new inventoryListElement ();
persistanceInventoryObjectInfo currentInventoryInfo = playerInventoryListToLoad.inventoryObjectList [j];
newInventoryListElement.Name = currentInventoryInfo.Name;
newInventoryListElement.amount = currentInventoryInfo.amount;
newInventoryListElement.infiniteAmount = currentInventoryInfo.infiniteAmount;
newInventoryListElement.inventoryObjectName = currentInventoryInfo.inventoryObjectName;
newInventoryListElement.categoryIndex = currentInventoryInfo.categoryIndex;
newInventoryListElement.elementIndex = currentInventoryInfo.elementIndex;
newInventoryListElement.isEquipped = currentInventoryInfo.isEquipped;
newInventoryListElement.quickAccessSlotIndex = currentInventoryInfo.quickAccessSlotIndex;
newInventoryListElement.useDurability = currentInventoryInfo.useDurability;
newInventoryListElement.durabilityAmount = currentInventoryInfo.durabilityAmount;
newInventoryListElement.maxDurabilityAmount = currentInventoryInfo.maxDurabilityAmount;
newInventoryListElement.objectIsBroken = currentInventoryInfo.objectIsBroken;
newInventoryListElement.isWeapon = currentInventoryInfo.isWeapon;
newInventoryListElement.isMeleeWeapon = currentInventoryInfo.isMeleeWeapon;
newInventoryListElement.projectilesInMagazine = currentInventoryInfo.projectilesInMagazine;
persistanceInfoList.Add (newInventoryListElement);
}
int inventorySlotAmount = playerInventoryListToLoad.inventorySlotAmount;
if (inventorySlotAmount > -1) {
mainInventoryManager.setInventorySlotAmountValue (inventorySlotAmount);
}
mainInventoryManager.setInventoryWasEmptyWhenSavedState (playerInventoryListToLoad.inventoryWasEmptyWhenSaved);
if (mainInventoryManager.isSetInfiniteSlotValuesOnSaveLoadActive ()) {
mainInventoryManager.setInfiniteSlotsState (playerInventoryListToLoad.infiniteSlots);
}
if (playerInventoryListToLoad.useOnlyBlueprintsUnlocked) {
GKC_Utils.setUseOnlyBlueprintsUnlockedState (mainInventoryManager.gameObject, true);
GKC_Utils.setBlueprintsUnlockedListValue (mainInventoryManager.gameObject, playerInventoryListToLoad.blueprintsUnlockedList);
}
if (playerInventoryListToLoad.anyObjectToCraftInTimeActive) {
GKC_Utils.setCraftObjectInTimeInfoList (mainInventoryManager.gameObject, playerInventoryListToLoad.craftObjectInTimeSimpleInfoList);
}
if (playerInventoryListToLoad.objectCategoriesToCraftAvailableAtAnyMoment != null && playerInventoryListToLoad.objectCategoriesToCraftAvailableAtAnyMoment.Count > 0) {
GKC_Utils.setObjectCategoriesToCraftAvailableAtAnyMomentValue (mainInventoryManager.gameObject, playerInventoryListToLoad.objectCategoriesToCraftAvailableAtAnyMoment);
}
mainInventoryManager.setLastWeaponCarriedOnHandsName (playerInventoryListToLoad.lastWeaponCarriedOnHandsName);
if (showDebugInfo) {
print ("\n\n");
print ("Number of inventory slots available: " + playerInventoryListToLoad.inventorySlotAmount);
print ("\n\n");
if (playerInventoryListToLoad.useOnlyBlueprintsUnlocked) {
print ("\n\n");
print ("Use only blueprints unlocked active with the amount: " + playerInventoryListToLoad.blueprintsUnlockedList.Count);
print ("\n\n");
}
}
if (removeSaveInfo) {
infoListToLoad.Remove (newPersistanceInventoryListBySaveSlotInfo);
BinaryFormatter bf = new BinaryFormatter ();
FileStream file = File.Create (currentSaveDataPath);
bf.Serialize (file, infoListToLoad);
file.Close ();
if (showDebugInfo) {
print ("REMOVE SLOT FROM INITIAL INVENTORY ON NEW GAME");
}
}
}
}
if (showDebugInfo) {
print ("\n\n");
print ("PLAYER INVENTORY");
print ("Inventory Loaded in Save Number " + saveNumberToLoad);
print ("Number of objects: " + persistanceInfoList.Count);
for (int j = 0; j < persistanceInfoList.Count; j++) {
inventoryListElement currentElement = persistanceInfoList [j];
print ("Object Name: " + currentElement.Name + " Amount: " + currentElement.amount);
if (currentElement.isWeapon && !currentElement.isMeleeWeapon) {
print ("Object is weapon with " + currentElement.projectilesInMagazine + " projectiles in the magazine");
}
}
}
loadInfoOnMainComponent ();
}
public persistanceInventoryListByPlayerInfo getPersistanceList (int playerID, bool showDebugInfo)
{
persistanceInventoryListByPlayerInfo newPersistanceInventoryListByPlayerInfo = new persistanceInventoryListByPlayerInfo ();
newPersistanceInventoryListByPlayerInfo.playerID = playerID;
mainInventoryManager.updateDurabilityAmountStateOnAllInventoryObjects ();
int inventorySlotAmount = mainInventoryManager.getInventorySlotAmount ();
newPersistanceInventoryListByPlayerInfo.inventorySlotAmount = inventorySlotAmount;
newPersistanceInventoryListByPlayerInfo.infiniteSlots = mainInventoryManager.isInfiniteSlotsActive ();
//Crafting elements
newPersistanceInventoryListByPlayerInfo.useOnlyBlueprintsUnlocked = GKC_Utils.isUseOnlyBlueprintsUnlockedActive (mainInventoryManager.gameObject);
if (newPersistanceInventoryListByPlayerInfo.useOnlyBlueprintsUnlocked) {
List<string> blueprintsUnlockedList = GKC_Utils.getBlueprintsUnlockedListValue (mainInventoryManager.gameObject);
if (blueprintsUnlockedList != null) {
newPersistanceInventoryListByPlayerInfo.blueprintsUnlockedList = new List<string> (blueprintsUnlockedList);
}
}
newPersistanceInventoryListByPlayerInfo.anyObjectToCraftInTimeActive = GKC_Utils.anyObjectToCraftInTimeActive (mainInventoryManager.gameObject);
if (newPersistanceInventoryListByPlayerInfo.anyObjectToCraftInTimeActive) {
newPersistanceInventoryListByPlayerInfo.craftObjectInTimeSimpleInfoList = GKC_Utils.getCraftObjectInTimeInfoList (mainInventoryManager.gameObject);
}
newPersistanceInventoryListByPlayerInfo.objectCategoriesToCraftAvailableAtAnyMoment = GKC_Utils.getObjectCategoriesToCraftAvailableAtAnyMomentValue (mainInventoryManager.gameObject);
newPersistanceInventoryListByPlayerInfo.lastWeaponCarriedOnHandsName = mainInventoryManager.getLastWeaponCarriedOnHandsName ();
if (showDebugInfo) {
print ("\n\n");
print ("Number of inventory slots available: " + inventorySlotAmount);
print ("\n\n");
if (newPersistanceInventoryListByPlayerInfo.useOnlyBlueprintsUnlocked) {
print ("\n\n");
print ("Use only blueprints unlocked active with the amount: " + newPersistanceInventoryListByPlayerInfo.blueprintsUnlockedList.Count);
print ("\n\n");
}
}
List<persistanceInventoryObjectInfo> newPersistanceInventoryObjectInfoList = new List<persistanceInventoryObjectInfo> ();
List<inventoryInfo> inventoryList = mainInventoryManager.getInventoryList ();
int inventoryListCount = inventoryList.Count;
bool inventoryWasEmptyWhenSaved = true;
for (int k = 0; k < inventoryListCount; k++) {
inventoryInfo currentInventoryInfo = inventoryList [k];
if (currentInventoryInfo.amount > 0) {
persistanceInventoryObjectInfo newPersistanceInventoryObjectInfo = new persistanceInventoryObjectInfo ();
newPersistanceInventoryObjectInfo.Name = currentInventoryInfo.Name;
newPersistanceInventoryObjectInfo.amount = currentInventoryInfo.amount;
newPersistanceInventoryObjectInfo.infiniteAmount = currentInventoryInfo.infiniteAmount;
newPersistanceInventoryObjectInfo.inventoryObjectName = currentInventoryInfo.Name;
newPersistanceInventoryObjectInfo.categoryIndex = currentInventoryInfo.categoryIndex;
newPersistanceInventoryObjectInfo.elementIndex = currentInventoryInfo.elementIndex;
newPersistanceInventoryObjectInfo.isEquipped = currentInventoryInfo.isEquipped;
newPersistanceInventoryObjectInfo.quickAccessSlotIndex = currentInventoryInfo.quickAccessSlotIndex;
newPersistanceInventoryObjectInfo.useDurability = currentInventoryInfo.useDurability;
newPersistanceInventoryObjectInfo.durabilityAmount = currentInventoryInfo.durabilityAmount;
newPersistanceInventoryObjectInfo.maxDurabilityAmount = currentInventoryInfo.maxDurabilityAmount;
newPersistanceInventoryObjectInfo.objectIsBroken = currentInventoryInfo.objectIsBroken;
newPersistanceInventoryObjectInfo.isWeapon = currentInventoryInfo.isWeapon;
newPersistanceInventoryObjectInfo.isMeleeWeapon = currentInventoryInfo.isMeleeWeapon;
if (newPersistanceInventoryObjectInfo.isWeapon && !newPersistanceInventoryObjectInfo.isMeleeWeapon) {
if (currentInventoryInfo.mainWeaponObjectInfo != null) {
newPersistanceInventoryObjectInfo.projectilesInMagazine = currentInventoryInfo.mainWeaponObjectInfo.getProjectilesInWeaponMagazine ();
}
}
newPersistanceInventoryObjectInfoList.Add (newPersistanceInventoryObjectInfo);
inventoryWasEmptyWhenSaved = false;
}
}
newPersistanceInventoryListByPlayerInfo.inventoryWasEmptyWhenSaved = inventoryWasEmptyWhenSaved;
if (showDebugInfo) {
print ("\n\n");
for (int j = 0; j < newPersistanceInventoryObjectInfoList.Count; j++) {
persistanceInventoryObjectInfo currentInfo = newPersistanceInventoryObjectInfoList [j];
print ("Object Name: " + currentInfo.Name + " Amount: " + currentInfo.amount + " category index " +
currentInfo.categoryIndex + " element index " + currentInfo.elementIndex);
if (currentInfo.isWeapon && !currentInfo.isMeleeWeapon) {
print ("Object is weapon with " + currentInfo.projectilesInMagazine + " projectiles in the magazine");
}
}
}
newPersistanceInventoryListByPlayerInfo.inventoryObjectList = newPersistanceInventoryObjectInfoList;
return newPersistanceInventoryListByPlayerInfo;
}
void loadInfoOnMainComponent ()
{
mainInventoryManager.setIsLoadingGameState (true);
initializeValues ();
if (persistanceInfoList != null) {
bool sendNewInventoryResult = true;
//when loading, it can be from a new game or from a continue/load action, so if the loaded inventory is an
//empty list, then:
//-when doing a new game, it should allow to use the initial inventory if configured
//-when loading/continuing a game, it should load the inventory list saved, even if empty
//check the state also when the player options menu is used on home menu
if (ignoreAssignLoadedInventoryIfEmpty) {
if (persistanceInfoList.Count == 0 && !mainInventoryManager.getInventoryWasEmptyWhenSaved ()) {
sendNewInventoryResult = false;
}
if (persistanceInfoList.Count == 0 && mainInventoryManager.getInventoryWasEmptyWhenSaved () && lastGameSavedOnHomeMenuValue) {
sendNewInventoryResult = false;
}
}
//print (persistanceInfoList.Count + " " + mainInventoryManager.getInventoryWasEmptyWhenSaved () + " " + lastGameSavedOnHomeMenuValue + " " +
//sendNewInventoryResult);
if (sendNewInventoryResult) {
mainInventoryManager.setNewInventoryListManagerList (persistanceInfoList);
}
}
}
void initializeValues ()
{
mainInventoryManager.initializeInventoryValues ();
}
public void saveGameContentFromEditor (int currentSaveNumber, int playerID, string currentSaveDataPath, bool showDebugInfo)
{
if (mainInventoryManager == null) {
return;
}
bool saveLocated = false;
bool playerLocated = false;
int saveSlotIndex = -1;
int listIndex = -1;
BinaryFormatter bf = new BinaryFormatter ();
FileStream file;
persistanceInventoryListByPlayerInfo inventoryListToSave = getPersistanceInventoryListElement (playerID, showDebugInfo);
persistanceInventoryListBySaveSlotInfo newPersistanceInventoryListBySaveSlotInfo = new persistanceInventoryListBySaveSlotInfo ();
List<persistanceInventoryListBySaveSlotInfo> infoListToSave = new List<persistanceInventoryListBySaveSlotInfo> ();
if (File.Exists (currentSaveDataPath)) {
bf = new BinaryFormatter ();
file = File.Open (currentSaveDataPath, FileMode.Open);
object currentData = bf.Deserialize (file);
infoListToSave = currentData as List<persistanceInventoryListBySaveSlotInfo>;
file.Close ();
}
int infoListToSaveCount = infoListToSave.Count;
for (int j = 0; j < infoListToSaveCount; j++) {
if (saveSlotIndex == -1) {
persistanceInventoryListBySaveSlotInfo currentSlot = infoListToSave [j];
if (currentSlot.saveNumber == currentSaveNumber) {
newPersistanceInventoryListBySaveSlotInfo = currentSlot;
saveLocated = true;
saveSlotIndex = j;
}
}
}
if (saveLocated) {
int playerInventoryListCount = newPersistanceInventoryListBySaveSlotInfo.playerInventoryList.Count;
int playerIDToSearch = inventoryListToSave.playerID;
for (int j = 0; j < playerInventoryListCount; j++) {
if (listIndex == -1 && newPersistanceInventoryListBySaveSlotInfo.playerInventoryList [j].playerID == playerIDToSearch) {
playerLocated = true;
listIndex = j;
}
}
}
if (showDebugInfo) {
print ("\n\n");
print ("EXTRA INFO\n");
print ("PLAYER INVENTORY");
print ("Number of objects: " + inventoryListToSave.inventoryObjectList.Count);
print ("Current Save Number " + currentSaveNumber);
print ("Save Located " + saveLocated);
print ("Player Located " + playerLocated);
print ("Player ID " + inventoryListToSave.playerID);
}
//if the save is located, check if the player id exists
if (saveLocated) {
//if player id exists, overwrite it
if (playerLocated) {
infoListToSave [saveSlotIndex].playerInventoryList [listIndex].inventoryObjectList = inventoryListToSave.inventoryObjectList;
} else {
infoListToSave [saveSlotIndex].playerInventoryList.Add (inventoryListToSave);
}
} else {
newPersistanceInventoryListBySaveSlotInfo.saveNumber = currentSaveNumber;
newPersistanceInventoryListBySaveSlotInfo.playerInventoryList.Add (inventoryListToSave);
infoListToSave.Add (newPersistanceInventoryListBySaveSlotInfo);
}
bf = new BinaryFormatter ();
file = File.Create (currentSaveDataPath);
bf.Serialize (file, infoListToSave);
file.Close ();
}
public persistanceInventoryListByPlayerInfo getPersistanceInventoryListElement (int playerID, bool showDebugInfo)
{
persistanceInventoryListByPlayerInfo newPersistanceInventoryListByPlayerInfo = new persistanceInventoryListByPlayerInfo ();
newPersistanceInventoryListByPlayerInfo.playerID = playerID;
List<persistanceInventoryObjectInfo> newPersistanceInventoryObjectInfoList = new List<persistanceInventoryObjectInfo> ();
List<inventoryListElement> inventoryListManagerList = mainInventoryManager.getCurrentInventoryListManagerList ();
int inventoryListManagerListCount = inventoryListManagerList.Count;
for (int k = 0; k < inventoryListManagerListCount; k++) {
persistanceInventoryObjectInfo newPersistanceInventoryObjectInfo = new persistanceInventoryObjectInfo ();
inventoryListElement currentElement = inventoryListManagerList [k];
newPersistanceInventoryObjectInfo.Name = currentElement.Name;
newPersistanceInventoryObjectInfo.amount = currentElement.amount;
newPersistanceInventoryObjectInfo.infiniteAmount = currentElement.infiniteAmount;
newPersistanceInventoryObjectInfo.inventoryObjectName = currentElement.inventoryObjectName;
newPersistanceInventoryObjectInfo.elementIndex = currentElement.elementIndex;
newPersistanceInventoryObjectInfo.categoryIndex = currentElement.categoryIndex;
if (showDebugInfo) {
print (newPersistanceInventoryObjectInfo.Name + " " + newPersistanceInventoryObjectInfo.amount);
}
newPersistanceInventoryObjectInfoList.Add (newPersistanceInventoryObjectInfo);
}
newPersistanceInventoryListByPlayerInfo.inventoryObjectList = newPersistanceInventoryObjectInfoList;
return newPersistanceInventoryListByPlayerInfo;
}
}