public override void SetupInteractableInformation()
{
base.SetupInteractableInformation();
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
// IF NO DATA ABOUT THE BUILDING YET
if (PlayerGameManager.GetInstance != null && playerData.buildingInformationData != null &&
playerData.buildingInformationData.Count > 0)
{
buildingInformation = TransitionManager.GetInstance.currentSceneManager.buildingInformationStorage.ObtainBuildingOperation(informationName);
BuildingSavedData tmp = playerData.buildingInformationData.Find(x => x.buildingName == buildingInformation.BuildingName);
if (tmp != null)
{
buildingInformation.buildingCondition = tmp.buildingCondition;
buildingInformation.buildingLevel = tmp.buildingLevel;
buildingInformation.buildingType = tmp.buildingType;
}
}
else if (TransitionManager.GetInstance != null)
{
buildingInformation = TransitionManager.GetInstance.currentSceneManager.buildingInformationStorage.ObtainBuildingOperation(informationName);
}
else if (testMode)
{
buildingInformation = BalconySceneManager.GetInstance.buildingInformationStorage.ObtainBuildingOperation(buildingType);
}
UpdateBuildingState();
}
public void ShowPotentialChanges()
{
if (ResourceInformationController.GetInstance == null)
{
return;
}
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
int tmp = 0;
List <ResourceReward> rewardTmp = new List <ResourceReward>();
ResourceReward reward = new ResourceReward();
for (int i = 0; i < optionPanelList.Count; i++)
{
tmp += optionPanelList[i].amountToSell * optionPanelList[i].pricePerItem;
ResourceReward tempReward = new ResourceReward();
int sold = optionPanelList[i].amountToSell;
tempReward.resourceType = ResourceType.Troops;
tempReward.unitName = optionPanelList[i].nameTitleText.text;
tempReward.rewardAmount = -sold;
rewardTmp.Add(tempReward);
}
reward.resourceType = currentResourceReturnType;
reward.rewardAmount = tmp;
rewardTmp.Add(reward);
ResourceInformationController.GetInstance.ShowCurrentPanelPotentialResourceChanges(rewardTmp);
}
public void InitializeBalconyPlayerData()
{
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
if (!playerData.balconyBuildingsAdded)
{
if (playerData.buildingInformationData == null)
{
playerData.buildingInformationData = new List <BuildingSavedData>();
}
for (int i = 0; i < buildingInformationStorage.buildingOperationList.Count; i++)
{
BuildingSavedData tmp = new BuildingSavedData();
tmp.buildingName = buildingInformationStorage.buildingOperationList[i].BuildingName;
tmp.buildingType = buildingInformationStorage.buildingOperationList[i].buildingType;
tmp.buildingLevel = buildingInformationStorage.buildingOperationList[i].buildingLevel;
if (TransitionManager.GetInstance != null && TransitionManager.GetInstance.isNewGame)
{
tmp.buildingCondition = BuildingCondition.Functioning;
}
else
{
tmp.buildingCondition = buildingInformationStorage.buildingOperationList[i].buildingCondition;
}
playerData.buildingInformationData.Add(tmp);
}
playerData.balconyBuildingsAdded = true;
}
}
public void ObtainSaves()
{
savePath = Application.persistentDataPath + "/Saves";
if (!Directory.Exists(savePath))
{
Directory.CreateDirectory(savePath);
}
DirectoryInfo tmp = new DirectoryInfo(savePath);
List <FileInfo> saveFileList = GetSavePlayerFiles(tmp);
BinaryFormatter bf = new BinaryFormatter();
if (saveFileList.Count > 0)
{
for (int i = 0; i < saveFileList.Count; i++)
{
if (File.Exists(saveFileList[i].ToString()))
{
bf = new BinaryFormatter();
FileStream file = File.Open(saveFileList[i].ToString(), FileMode.Open);
PlayerKingdomData temp = new PlayerKingdomData();
temp = (PlayerKingdomData)bf.Deserialize(file);
saveDataList.Add(temp);
file.Close();
}
}
}
}
public void OnEnable()
{
if (PlayerGameManager.GetInstance != null)
{
curPlayer = PlayerGameManager.GetInstance.playerData;
}
}
public void SetType(ResourceType thisType)
{
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
currentTechs.Clear();
currentType = thisType;
for (int i = 0; i < playerData.currentTechnologies.Count; i++)
{
if (playerData.currentTechnologies[i].improvedType == thisType)
{
BaseTechnology tmp = new BaseTechnology().ConverToData(playerData.currentTechnologies[i]);
tmp.techIcon = TechnologyManager.GetInstance.techStorage.technologies.Find(x => x.technologyName == tmp.technologyName).techIcon;
currentTechs.Add(tmp);
}
}
for (int i = 0; i < currentTechs.Count; i++)
{
techOptions[i].techIcon.sprite = currentTechs[i].techIcon;
techOptions[i].bgTechFill.fillAmount = (float)currentTechs[i].currentLevel / (float)currentTechs[i].goldLevelRequirements.Count;
}
}
public void SetupMapBehavior()
{
if (PlayerGameManager.GetInstance != null)
{
playerCampaignData = PlayerGameManager.GetInstance.campaignData;
playerKingdomData = PlayerGameManager.GetInstance.playerData;
}
}
public List <EventDecisionData> FilterEvents(List <EventDecisionData> thisData, int weekCount, bool removeStory = false)
{
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
List <EventDecisionData> tmp = thisData;
return(tmp);
}
public override void Start()
{
base.Start();
if (PlayerGameManager.GetInstance != null)
{
curPlayer = PlayerGameManager.GetInstance.playerData;
curCampaign = PlayerGameManager.GetInstance.campaignData;
}
EventBroadcaster.Instance.AddObserver(EventNames.WEEKLY_UPDATE, WeeklyProductionProgress);
}
public void UpdatePages(int actionIdx)
{
if (PlayerGameManager.GetInstance != null)
{
playerData = new PlayerKingdomData();
playerData = PlayerGameManager.GetInstance.playerData;
}
if (currentPage != null)
{
myController.HideInfoBlocker();
currentPage.gameObject.SetActive(false);
}
cardIdx = actionIdx;
currentPage = informationPageList[cardIdx];
if (currentPage != null)
{
currentPage.gameObject.SetActive(true);
}
switch (buildingType)
{
case BuildingType.Shop:
UpdateShop();
break;
case BuildingType.Barracks:
UpdateBarracks();
break;
case BuildingType.Tavern:
UpdateTavern();
break;
case BuildingType.Smithery:
break;
case BuildingType.Houses:
UpdateHouses();
break;
case BuildingType.Farm:
UpdateFarm();
break;
case BuildingType.Market:
UpdateMarket();
break;
default:
break;
}
}
public void SetupThisPanel(PlayerKingdomData thisData, int idx)
{
savePanelList[idx].gameObject.SetActive(true);
savePanelList[idx].kingdomName.text = thisData.kingdomsName;
savePanelList[idx].coinsCount.text = thisData.coins.ToString();
savePanelList[idx].populationCount.text = thisData.population.ToString();
savePanelList[idx].foodCount.text = thisData.foods.ToString();
savePanelList[idx].troopsCount.text = thisData.GetTotalTroops.ToString();
savePanelList[idx].weeksCount.text = thisData.weekCount.ToString();
savePanelList[idx].myController = this;
}
public void InitializeData()
{
PlayerKingdomData data = PlayerGameManager.GetInstance.playerData;
foodControl.SetupStorageCapacity(data.safeFood);
troopControl.SetupStorageCapacity(data.barracksCapacity);
villagerControl.SetupStorageCapacity(data.safePopulation);
coinControl.SetupStorageCapacity(data.coinsCapacity);
foodControl.SetResource(data.foods);
troopControl.SetResource(data.GetTotalTroops);
villagerControl.SetResource(data.population);
coinControl.SetResource(data.coins);
}
public void DeleteData()
{
savePath = Application.persistentDataPath + "/Saves";
if (currentData != null)
{
saveDataList.Remove(currentData);
File.Delete(savePath + "/" + currentData._fileName);
#if UNITY_EDITOR
UnityEditor.AssetDatabase.Refresh();
#endif
currentData = null;
}
}
public void Start()
{
temporaryKingdom = new PlayerKingdomData();
for (int i = 0; i < resourcePagesList.Count; i++)
{
resourcePagesList[i].myController = this;
}
for (int i = 0; i < kingdomDescriptionList.Count; i++)
{
kingdomDescriptionList[i].myController = this;
}
SetupInitialData();
distributeCounter.curCount = distributeAmount;
}
public void SetNewSaveData(PlayerKingdomData newData, PlayerCampaignData campaignData)
{
if (saveDataList == null)
{
saveDataList = new List <PlayerKingdomData>();
}
// Check last Data Index
saveDataList.Add(newData);
if (saveCampaignDataList == null)
{
saveCampaignDataList = new List <PlayerCampaignData>();
}
saveCampaignDataList.Add(campaignData);
SavePlayerCampaignData();
SavePlayerData();
}
public void PlayPrologue()
{
PlayerKingdomData tmp = new PlayerKingdomData();
tmp = temporaryKingdom;
SaveLoadManager.GetInstance.inheritanceData = new PlayerKingdomData();
SaveLoadManager.GetInstance.inheritanceData = tmp;
Debug.Log("CONVERTING INHERITANCE TO SAVELOAD MANAGER");
myPanel.PlayCloseAnimation();
if (CreationSceneManager.GetInstance != null)
{
CreationSceneManager.GetInstance.StartPrologue();
UpdatePlayerHero();
}
playPrologueTab.CloseWindow();
}
public void PrologueEvents()
{
playerData = PlayerGameManager.GetInstance.playerData;
EventDecisionData event1 = eventStorage.GetEventByTitle("Scout of the Wilds");
EventDecisionData event2 = eventStorage.GetEventByTitle("Angered Fur Khan");
EventDecisionData event3 = eventStorage.GetEventByTitle("Unexpected Crusade");
queuedEventsList.Add(event1);
queuedEventsList.Add(event2);
queuedEventsList.Add(event3);
eventFinished = PlayerGameManager.GetInstance.playerData.eventFinished;
weeklyEvents = 3;
isPrologue = true;
AllowStartEvent(); // PROLOGUE EVENTS
ResourceInformationController.GetInstance.currentPanel.weekController.UpdateEndButton(0, weeklyEvents, ShowEndWeekPrologue);
}
public void OpenSellTroopsPanel()
{
ClearCurrentOptionPanelList();
currentResourceReturnType = ResourceType.Coin;
/// CHANGE THE PRICE BY HAVING A PRICE STORAGE
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
if (playerData.troopsList != null)
{
for (int i = 0; i < playerData.troopsList.Count; i++)
{
GameObject tmp = (GameObject)Instantiate(optionPanelPrefab, optionParent);
optionPanelList.Add(tmp.GetComponent <SubOptionPanel>());
optionPanelList[optionPanelList.Count - 1].myController = this;
optionPanelList[optionPanelList.Count - 1].SetupOptionPanel(playerData.troopsList[i].totalUnitCount, playerData.troopsList[i].unitInformation.unitPrice, playerData.troopsList[i].unitInformation.unitName);
}
}
}
public void SellTroops()
{
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
int tmp = 0;
for (int i = 0; i < optionPanelList.Count; i++)
{
tmp += optionPanelList[i].amountToSell * optionPanelList[i].pricePerItem;
int soldTroopCount = optionPanelList[i].amountToSell;
PlayerGameManager.GetInstance.RemoveResource(soldTroopCount, ResourceType.Troops, playerData.troopsList[i].unitInformation.unitName);
ResourceInformationController.GetInstance.currentPanel.UpdateResourceData(ResourceType.Troops, soldTroopCount, false);
}
PlayerGameManager.GetInstance.ReceiveResource(tmp, currentResourceReturnType);
myController.myController.currentBuildingPanel.UpdateBarracks();
ResourceInformationController.GetInstance.currentPanel.UpdateResourceData(currentResourceReturnType, tmp);
ResourceInformationController.GetInstance.HideCurrentPanelPotentialResourceChanges();
ClearCurrentOptionPanelList();
ClosePanel();
}
public bool RequirementPassed(PlayerKingdomData thisKingdom)
{
if (foodReq > thisKingdom.foods)
{
return(false);
}
if (populationReq > thisKingdom.population)
{
return(false);
}
if (troopReq > thisKingdom.GetTotalTroops)
{
return(false);
}
if (coinReq > thisKingdom.coins)
{
return(false);
}
return(true);
}
public override void PreOpenManager()
{
base.PreOpenManager();
Debug.Log("Starting Kingdom Events Manager");
playerData = new PlayerKingdomData();
playerData = PlayerGameManager.GetInstance.playerData;
// ADD ONBOARDING HERE ONCE BALANCING IS DONE
if (PlayerGameManager.GetInstance != null)
{
if (TransitionManager.GetInstance.isNewGame && !DramaticActManager.GetInstance.currentlyPlayingDrama)
{
}
else if (TransitionManager.GetInstance.currentSceneManager.sceneType == SceneType.Courtroom)
{
PlayerGameManager mgr = PlayerGameManager.GetInstance;
LoadSavedData(mgr.playerData.queuedDataEventsList, mgr.playerData.curDataEvent, mgr.playerData.curDataStory);
// CHECKS IF LOADED DATA STILL HAS QUEUED EVENTS
if (mgr.playerData.eventFinished < 3)
{
if (mgr.playerData.queuedDataEventsList.Count > 0 || mgr.playerData.curDataEvent != null && !string.IsNullOrEmpty(mgr.playerData.curDataEvent.title))
{
AllowStartEvent(); // PREOPEN
}
else
{
StartWeekEvents();
}
}
}
}
else
{
StartWeekEvents();
}
}
public void EndPrologueScene(PlayerKingdomData temporaryKingdom)
{
if (SaveLoadManager.GetInstance != null)
{
PlayerCampaignData temp = new PlayerCampaignData();
temp.fileData = true;
temp.travellerList = new List <BaseTravellerData>();
temp.mapPointList = new List <Maps.MapPointInformationData>();
temp.mapPointList.AddRange(TransitionManager.GetInstance.kingdomMapStorage.mapPointsStorage);
Debug.Log("RESOURCE: " + temporaryKingdom.coins);
SaveLoadManager.GetInstance.SetNewSaveData(temporaryKingdom, temp);
temporaryKingdom._fileName = SaveLoadManager.GetInstance.saveDataList[SaveLoadManager.GetInstance.saveDataList.Count - 1]._fileName;
temp._fileName = SaveLoadManager.GetInstance.saveCampaignDataList[SaveLoadManager.GetInstance.saveCampaignDataList.Count - 1]._fileName;
PlayerGameManager.GetInstance.ReceiveData(temporaryKingdom);
PlayerGameManager.GetInstance.ReceiveCampaignData(temp);
}
if (TransitionManager.GetInstance != null)
{
TransitionManager.GetInstance.LoadScene(SceneType.Courtroom);
}
}
public void UpdateKingdomResources()
{
PlayerKingdomData playerData = PlayerGameManager.GetInstance.playerData;
int tmpAmount = 0;
for (int i = 0; i < curDecision.rewards.Count; i++)
{
switch (curDecision.rewards[i].resourceType)
{
case ResourceType.Coin:
if (curDecision.rewards[i].rewardAmount < 0)
{
tmpAmount = Mathf.Abs(curDecision.rewards[i].rewardAmount);
tmpAmount = playerData.coins - tmpAmount;
if (tmpAmount < 0)
{
playerResourceLacking = true;
}
}
continue;
case ResourceType.Troops:
if (curDecision.rewards[i].rewardAmount < 0)
{
tmpAmount = Mathf.Abs(curDecision.rewards[i].rewardAmount);
tmpAmount = playerData.ObtainTotalTroops() - tmpAmount;
if (tmpAmount < 0)
{
playerResourceLacking = true;
}
}
continue;
case ResourceType.Food:
if (curDecision.rewards[i].rewardAmount < 0)
{
tmpAmount = Mathf.Abs(curDecision.rewards[i].rewardAmount);
tmpAmount = playerData.foods - tmpAmount;
if (tmpAmount < 0)
{
playerResourceLacking = true;
}
}
continue;
case ResourceType.Population:
if (curDecision.rewards[i].rewardAmount < 0)
{
tmpAmount = Mathf.Abs(curDecision.rewards[i].rewardAmount);
tmpAmount = playerData.population - tmpAmount;
if (tmpAmount < 0)
{
playerResourceLacking = true;
}
}
continue;
}
if (playerResourceLacking)
{
break;
}
}
if (playerResourceLacking)
{
isClickable = false;
if (myBtn == null)
{
myBtn = this.GetComponent <Button>();
}
myBtn.interactable = isClickable;
}
else
{
isClickable = true;
if (myBtn == null)
{
myBtn = this.GetComponent <Button>();
}
myBtn.interactable = isClickable;
}
}
public void SetCurrentData(int saveSlot)
{
currentData = saveDataList[saveSlot];
currentCampaignData = saveCampaignDataList[saveSlot];
}
public List <EventDecisionData> ObtainWeeklyEvents(TerritoryLevel thisLevel, int eventCount, PlayerKingdomData playerData, bool inStory = false)
{
List <EventDecisionData> result = new List <EventDecisionData>();
curPlayerData = playerData;
List <EventDecisionData> forcedEvent = new List <EventDecisionData>();
#region DEV DEBUGGING
if (EnableDebugging)
{
if (!KingdomManager.GetInstance.isInStory && !playerData.IsStoryArcFinished(arcForced))
{
// ADD INITIAL EVENT FIRST
if (initialEventOnly)
{
forcedEvent.Add(ForcedInitialStoryEventDataToReturn());
result.Add(forcedEvent[forcedEvent.Count - 1]);
eventCount -= forcedEvent.Count;
}
// GET ALL STORY ARC EVENT
else if (allStoryArcEvents)
{
forcedEvent.AddRange(ForcedStoryEventsDataToReturn());
result.AddRange(forcedEvent);
eventCount -= forcedEvent.Count;
}
}
}
#endregion
if (result.Count >= eventCount)
{
return(result);
}
else
{
// GET TERRITORY
result.AddRange(GetTerritoryFilteredEvents(thisLevel));
// Filter by Difficulty
if (EnableDebugging && forceDifficulty)
{
result = ForceDifficultyFilteredEvent(Difficultyforced, result);
}
else
{
result = GetDifficultyRolledEvents(curPlayerData.level, result);
}
if (!KingdomManager.GetInstance.isInStory)
{
//Remove other Arcs
if (EnableDebugging && forceArc)
{
result = FilterToInitialStoryArcEvent(result, arcForced);
}
// FILTER BY STORY
if (!initialEventOnly && !inStory)
{
// CHECK IF RESULT HAS STORIES, REMOVE ALL BUT 1.
result = GetTerritoryDifficultyFilteredEvents(result);
}
}
else
{
List <EventDecisionData> nonStory = new List <EventDecisionData>();
nonStory.AddRange(result.FindAll(x => !x.isStoryArc));
result = result.FindAll(x => x.isStoryArc && x.storyArc == KingdomManager.GetInstance.currentStory.storyTitle);
result.AddRange(nonStory);
}
// GET THE TOP 3
List <EventDecisionData> finalResult = new List <EventDecisionData>();
List <int> randomEvents = new List <int>();
// ALWAYS HAVE THE FORCED EVENTS INSIDE THE RESULT.
if (EnableDebugging)
{
if (forcedEvent.Count > 0)
{
for (int i = 0; i < result.Count; i++)
{
if (forcedEvent.Find(x => x.title == result[i].title) != null)
{
randomEvents.Add(i);
}
}
}
}
// Debug.Log("RESULT COUNT: " + result.Count);
for (int i = 0; i < eventCount; i++)
{
int tmp = UnityEngine.Random.Range(0, result.Count - 1);
if (randomEvents.Contains(tmp))
{
i--;
}
else
{
randomEvents.Add(tmp);
}
}
for (int i = 0; i < randomEvents.Count; i++)
{
finalResult.Add(result[randomEvents[i]]);
}
// Debug.Log("Final Result Count: " + finalResult.Count);
return(finalResult);
}
}
// CALL THIS WHEN PLAYER WANTS TO CONTINUE THE GAME
public void LoadGameData(PlayerKingdomData thisData)
{
}
public void ReceiveData(PlayerKingdomData newData)
{
playerData._fileName = newData._fileName;
playerData.fileData = newData.fileData;
playerData.kingdomsName = newData.kingdomsName;
playerData.dynastyName = newData.dynastyName;
playerData.level = newData.level;
playerData.weekCount = newData.weekCount;
playerData.finishedStories = newData.finishedStories;
if (newData.queuedDataEventsList != null && newData.queuedDataEventsList.Count > 0)
{
if (playerData.queuedDataEventsList == null)
{
playerData.queuedDataEventsList = new List <EventDecisionData>();
}
playerData.queuedDataEventsList.AddRange(newData.queuedDataEventsList);
}
playerData.curDataEvent = newData.curDataEvent;
playerData.curDataStory = newData.curDataStory;
playerData.eventFinished = newData.eventFinished;
Debug.Log("-------[Events Finished: " + playerData.eventFinished + " NewData Finish : " + newData.eventFinished + "]-------");
playerData.barracksCapacity = newData.barracksCapacity;
playerData.troopsLoyalty = newData.troopsLoyalty;
playerData.troopsList = new List <TroopsInformation>();
if (newData.troopsList != null && newData.troopsList.Count > 0)
{
for (int i = 0; i < newData.troopsList.Count; i++)
{
playerData.troopsList.Add(newData.troopsList[i]);
}
}
playerData.troopsMercList = new List <TroopsInformation>();
if (newData.troopsMercList != null && newData.troopsMercList.Count > 0)
{
for (int i = 0; i < newData.troopsMercList.Count; i++)
{
playerData.troopsMercList.Add(newData.troopsMercList[i]);
}
}
playerData.population = newData.population;
playerData.safePopulation = newData.safePopulation;
playerData.pouplationLoyalty = newData.pouplationLoyalty;
playerData.curTaxWeeksCounter = newData.curTaxWeeksCounter;
playerData.canReceiveTax = newData.canReceiveTax;
playerData.farmerCount = newData.farmerCount;
playerData.herdsmanCount = newData.herdsmanCount;
playerData.storageKeeperCount = newData.storageKeeperCount;
playerData.populationBurst = newData.populationBurst;
playerData.potentialRefugee = newData.potentialRefugee;
playerData.potentialMerchantArrival = newData.potentialMerchantArrival;
playerData.balconyBuildingsAdded = newData.balconyBuildingsAdded;
playerData.buildingInformationData = newData.buildingInformationData;
playerData.potentialGoodsMerchant = newData.potentialGoodsMerchant;
playerData.potentialExoticMerchant = newData.potentialExoticMerchant;
playerData.potentialEquipsMerchant = newData.potentialEquipsMerchant;
playerData.potentialCommonHero = newData.potentialCommonHero;
playerData.potentialRareHero = newData.potentialRareHero;
playerData.potentialLegHero = newData.potentialLegHero;
playerData.potentialMercenary = newData.potentialMercenary;
playerData.myHeroes = new List <BaseHeroInformationData>();
if (newData.myHeroes != null && newData.myHeroes.Count > 0)
{
Debug.Log("Temporary Kingdom Heroes Count: " + newData.myHeroes.Count + " And Skill Count: " + newData.myHeroes[0].skillsList.Count);
for (int i = 0; i < newData.myHeroes.Count; i++)
{
BaseHeroInformationData tmp = new BaseHeroInformationData();
tmp.damageGrowthRate = newData.myHeroes[i].damageGrowthRate;
tmp.healthGrowthRate = newData.myHeroes[i].healthGrowthRate;
tmp.speedGrowthRate = newData.myHeroes[i].speedGrowthRate;
tmp.unitInformation = newData.myHeroes[i].unitInformation;
tmp.equipments = newData.myHeroes[i].equipments;
tmp.skillsList = new List <BaseSkillInformationData>();
tmp.skillsList.AddRange(newData.myHeroes[i].skillsList);
playerData.myHeroes.Add(tmp);
}
}
playerData.tavernHeroes = new List <BaseHeroInformationData>();
if (newData.tavernHeroes != null && newData.tavernHeroes.Count > 0)
{
for (int i = 0; i < newData.tavernHeroes.Count; i++)
{
BaseHeroInformationData tmp = new BaseHeroInformationData();
tmp.damageGrowthRate = newData.tavernHeroes[i].damageGrowthRate;
tmp.healthGrowthRate = newData.tavernHeroes[i].healthGrowthRate;
tmp.speedGrowthRate = newData.tavernHeroes[i].speedGrowthRate;
tmp.unitInformation = newData.tavernHeroes[i].unitInformation;
tmp.equipments = newData.tavernHeroes[i].equipments;
playerData.tavernHeroes.Add(tmp);
}
}
playerData.myItems = new List <ItemInformationData>();
if (newData.myItems != null && newData.myItems.Count > 0)
{
for (int i = 0; i < newData.myItems.Count; i++)
{
GameItems.ItemInformationData tmp = newData.myItems[i];
playerData.myItems.Add(tmp);
}
}
playerData.currentShopMerchants = new List <BaseMerchantInformationData>();
if (newData.currentShopMerchants != null)
{
for (int i = 0; i < newData.currentShopMerchants.Count; i++)
{
BaseMerchantInformationData tmp = new BaseMerchantInformationData();
tmp.merchantName = newData.currentShopMerchants[i].merchantName;
tmp.itemsSold = newData.currentShopMerchants[i].itemsSold;
playerData.currentShopMerchants.Add(tmp);
}
}
Debug.Log("Food Count Before: " + newData.foods);
playerData.foods = newData.foods;
Debug.Log("Food Count After: " + newData.foods);
playerData.safeFood = newData.safeFood;
playerData.cows = newData.cows;
playerData.safeCows = newData.safeCows;
playerData.barnExpansion = newData.barnExpansion;
playerData.curGrainWeeksCounter = newData.curGrainWeeksCounter;
playerData.canReceiveGrainProduce = newData.canReceiveGrainProduce;
playerData.curCowBirthCounter = newData.curCowBirthCounter;
playerData.canReceiveNewCows = newData.canReceiveNewCows;
playerData.coins = newData.coins;
playerData.coinsCapacity = newData.coinsCapacity;
playerData.curMonthTaxCounter = newData.curMonthTaxCounter;
playerData.canReceiveMonthlyTax = newData.canReceiveMonthlyTax;
playerData.currentTechnologies = new List <BaseTechnologyData>();
if (newData.currentTechnologies != null && newData.currentTechnologies.Count > 0)
{
for (int i = 0; i < newData.currentTechnologies.Count; i++)
{
BaseTechnologyData tmp = new BaseTechnologyData();
tmp.technologyName = newData.currentTechnologies[i].technologyName;
tmp.improvedType = newData.currentTechnologies[i].improvedType;
tmp.goldLevelRequirements = newData.currentTechnologies[i].goldLevelRequirements;
tmp.currentLevel = newData.currentTechnologies[i].currentLevel;
tmp.goldRequirement = newData.currentTechnologies[i].goldRequirement;
tmp.curGold = newData.currentTechnologies[i].curGold;
tmp.bonusIncrement = newData.currentTechnologies[i].bonusIncrement;
tmp.troopTechType = newData.currentTechnologies[i].troopTechType;
tmp.popTechType = newData.currentTechnologies[i].popTechType;
tmp.foodTechType = newData.currentTechnologies[i].foodTechType;
tmp.coinTechType = newData.currentTechnologies[i].coinTechType;
tmp.effectMesg = newData.currentTechnologies[i].effectMesg;
tmp.wittyMesg = newData.currentTechnologies[i].wittyMesg;
playerData.currentTechnologies.Add(tmp);
}
}
}
