var plantController =

ControllerManager.GetInstance<WorldManager>().GetController<PlantCon

troller>();

foreach (var plant in plantController.plantsData.Values){

var plantPanel = Instantiate(plantPanelPrefab, content);

plantPanel.Initialize(plant.Name);}}}

PlantPanel.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;

using TMPro;

public class PlantPanel : MonoBehaviour{

[SerializeField] Image PlantIcon;

[SerializeField] TextMeshProUGUI NameCountTextMesh;

[SerializeField] TextMeshProUGUI CoinTextMesh;

[SerializeField] Button CoinButton;

PlayerController playerController;

PlantData plantData;

string Name;

public void Initialize(string Name){

this.Name = Name;}

void Start(){

playerController =

ControllerManager.GetInstance<WorldManager>().GetController<PlayerCo

ntroller>();

var plantController =

ControllerManager.GetInstance<WorldManager>().GetController<PlantCon

troller>();

plantData = plantController.plantsData[Name];

PlantIcon.sprite = plantData.LastSprite;

CoinButton.onClick.AddListener(SellPlant);}

public void SellPlant(){

playerController.Inventory.SellItem(Name);}

void Update(){

int count = playerController.Inventory.GetItemCount(Name);

NameCountTextMesh.SetText($"{plantData.Name}" + (count > 0 ?

$"\n{count}" : string.Empty));

CoinTextMesh.SetText($"{count * plantData.Price}");}}

UpgradeUI.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class UpgradeUI : MonoBehaviour{

public static UpgradeUI Instance;

[SerializeField] UpgradeElement panelPrefab;

public Transform content;

public PlayerController playerController;

private void Awake(){

Instance = this;}

private void Start(){

playerController =

ControllerManager.GetInstance<WorldManager>().GetController<PlayerCo

ntroller>();}

public void RegenerateUpgradePanel(List<Upgrade> upgrades){

for(int i = 0; i < content.childCount; i++)

Destroy(content.GetChild(i).gameObject);

foreach (var upgrade in upgrades){

var upgradeElement = Instantiate(panelPrefab, content);

upgradeElement.Initialize(this, upgrade);}}}

UpgradeElement.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;

using TMPro;

public class UpgradeElement : MonoBehaviour{

UpgradeUI ui;

Upgrade upgrade;

[SerializeField] TextMeshProUGUI Name;

[SerializeField] TextMeshProUGUI Description;

[SerializeField] TextMeshProUGUI Price;

[SerializeField] Button BuyButton;

private void Update(){

Price.SetText(upgrade.prices[upgrade.currentLevel].ToString());}

public void Initialize(UpgradeUI ui, Upgrade upgrade){

if(upgrade.currentLevel==upgrade.maxLevel){

Destroy(gameObject);

return;}

this.ui = ui;

this.upgrade = upgrade;

Name.SetText(upgrade.upgradeData.Name);

Description.SetText(upgrade.upgradeData.Description);

BuyButton.onClick.AddListener(OnBuyButtonClick);}

public void OnBuyButtonClick(){

if (upgrade.currentLevel < upgrade.prices.Count &&

ui.playerController.Inventory.RemoveCoins(upgrade.prices[upgrade.current

Level]))

upgrade.IncreaseLevel();

if (upgrade.currentLevel == upgrade.maxLevel){

Destroy(gameObject);

return;}}}

Upgrade.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

[System.Serializable]

public class Upgrade{

public UpgradeData upgradeData;

public int startLevel;

public int currentLevel;

public int maxLevel => prices.Count;

public List<int> prices;

public List<GameObject> lockedObjects;

public void EnableObjects(){

for (int i = 0; i < currentLevel; i++)

lockedObjects[i].SetActive(true);

for (int i = currentLevel; i < maxLevel; i++)

lockedObjects[i].SetActive(false);}

public void IncreaseLevel(){

currentLevel++;

EnableObjects();}}

UpgradeData.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

[CreateAssetMenu(menuName = "Data/Upgrade", fileName = "New

Upgrade Data")]

public class UpgradeData : ScriptableObject{

public string Name;

public string Description;}

UpgradePlate.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class UpgradePlate : Usable{

protected override void RegenerateUpgradePanel(){

panel.RegenerateUpgradePanel(upgrades);}}

Usable.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public abstract class Usable : MonoBehaviour, ISavable{

protected UIController controller;

protected UpgradeUI panel => UpgradeUI.Instance;

public string ID;

public List<Upgrade> upgrades = new List<Upgrade>();

protected virtual void Start(){

controller =

ControllerManager.GetInstance<WorldManager>().GetController<UIContro

ller>();

foreach (var upgrade in upgrades)

upgrade.currentLevel = upgrade.startLevel;

saveController =

ControllerManager.GetInstance<StaticControllerManager>().GetController<

SaveController>();

onDestroy = saveController.InitializeSavable(this);

Load();

foreach (var upgrade in upgrades)

upgrade.EnableObjects();

int full = 0;

foreach (var upgrade in upgrades)

if (upgrade.currentLevel >= upgrade.maxLevel)

full++;

if (full == upgrades.Count)

gameObject.SetActive(false);}

public virtual void OnUse(){

int full = 0;

foreach (var upgrade in upgrades)

if (upgrade.currentLevel >= upgrade.maxLevel)

full++;

if (full == upgrades.Count){

gameObject.SetActive(false);

controller.HideUpgradePanel();

return;}

controller.ReverseUpgradePanel();

RegenerateUpgradePanel();}

protected virtual void RegenerateUpgradePanel() { }

private SaveController saveController;

private System.Action onDestroy;

public void Load(){

foreach (var upgrade in upgrades){

if

(saveController.LoadAsInt($"{ID}_{upgrade.upgradeData.Name}_currentL

evel", out int level)){

upgrade.currentLevel = level;}}}

public void Save(){

foreach (var upgrade in upgrades) {

saveController.SaveAsInt($"{ID}_{upgrade.upgradeData.Name}_currentLe

vel", upgrade.currentLevel);}}

public void OnDestroy(){

onDestroy();}}

LightController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.Rendering.Universal;

public class LightController : Controller{

[SerializeField] Light2D global;

public float changeTime;

[Range(0f, 1f)]

public float minGlobalIntensity;

[Range(0f, 1f)]

public float maxGlobalIntensity;

private bool isDay = true;

Coroutine change;

public override void OnStart(){

global.intensity = maxGlobalIntensity;}

public void SmoothChangeTime(){

if (change != null)

StopCoroutine(change);

change = StartCoroutine(ChaneProcess());}

IEnumerator ChaneProcess(){

float changeTime = this.changeTime;

float countTicks = changeTime / 0.02f;

float difference = 1 / countTicks;

switch (isDay){

case true:

while (global.intensity > minGlobalIntensity){

global.intensity = Mathf.Clamp(global.intensity - difference,

minGlobalIntensity, maxGlobalIntensity);

yield return new WaitForFixedUpdate();}

isDay = false;

break;

case false:

while (global.intensity < maxGlobalIntensity){

global.intensity = Mathf.Clamp(global.intensity + difference,

minGlobalIntensity, maxGlobalIntensity);

yield return new WaitForFixedUpdate();}

isDay = true;

break;}}}

MusicController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using System.Threading.Tasks;

public class MusicController : Controller{

[SerializeField] AudioClip day;

[SerializeField] AudioClip night;

AudioSource source;

private float startVolume;

enum Music{

Day,

Night}

private Music currentMusicPlay = Music.Day;

public override void OnStart(){

source = GetComponent<AudioSource>();

currentMusicPlay = Music.Day;

startVolume = source.volume;}

private void Update(){}

Coroutine volumeDownCoroutine;

Coroutine volumeUpCoroutine;

public async void ChangeMusic(){

if (volumeDownCoroutine != null)

StopCoroutine(volumeDownCoroutine);

volumeDownCoroutine = StartCoroutine(VolumeDown());

while (source.isPlaying)

await Task.Yield();

switch (currentMusicPlay){

case Music.Day:

source.clip = night;

currentMusicPlay = Music.Night;

break;

case Music.Night:

source.clip = day;

currentMusicPlay = Music.Day;

break;}

if (volumeUpCoroutine != null)

StopCoroutine(volumeUpCoroutine);

volumeUpCoroutine = StartCoroutine(VolumeUp());

source.Play();}

IEnumerator VolumeDown(){

if (volumeUpCoroutine != null)

StopCoroutine(volumeUpCoroutine);

float downTime = 3f;

float countTicks = downTime / 0.02f;

float substract = 1 / countTicks;

while (source.volume > 0){

source.volume -= substract;

yield return new WaitForFixedUpdate();}

source.Stop();}

IEnumerator VolumeUp(){

if (volumeDownCoroutine != null)

StopCoroutine(volumeDownCoroutine);

float downTime = 2.5f;

float countTicks = downTime / 0.02f;

float add = 1 / countTicks;

while (source.volume < startVolume){

source.volume += add;

yield return new WaitForFixedUpdate();}}}

PlantController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class PlantController : Controller{

PlayerController playerController;

public List<Plant> plants = new List<Plant>();

[SerializeField] List<PlantData> _plantsData = new List<PlantData>();

public Dictionary<string, PlantData> plantsData = new Dictionary<string,

PlantData>();

public override void OnStart(){

foreach(var plant in _plantsData)

plantsData.Add(plant.Name, plant);

StartCoroutine(Grow());

playerController = ParentManager.GetController<PlayerController>();}

IEnumerator Grow(){

while(true){

yield return new WaitForSeconds(1);

for(int i = 0; i < plants.Count; i++){

plants[i].Grow();}}}

public Sprite GetPlantIcon(){

return null;}

public void AddPlant(Plant plant){

plants.Add(plant);}

public void RemovePlant(Plant plant){

plants.Remove(plant);}

public void Harvest(Gardenbed gardenbed){

int count =

Random.Range((int)gardenbed.PlantData.DropCount.x,

(int)gardenbed.PlantData.DropCount.y);

playerController.AddToInventoryInItem(count,

gardenbed.PlantData.Name);}}

PlayerController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class PlayerController : Controller{

public PlantController plantController;

Inventory inventory;

public Inventory Inventory => inventory;

public override void OnStart(){

inventory = GetComponent<Inventory>();

plantController = ParentManager.GetController<PlantController>();}

public void AddToInventoryInItem(int count, string name){

inventory.AddInItem(count, name);}}

SaveController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Newtonsoft.Json;

using System.IO;

public class SaveController : Controller{

private string SavePath;

private string IntSaveName = "IntDictionary.json";

private string FloatSaveName = "FloatDictionary.json";

private string FullIntPath => Path.Combine(SavePath, IntSaveName);

private string FullFloatPath => Path.Combine(SavePath, FloatSaveName);

private Dictionary<string, int> dataInt = new Dictionary<string, int>();

private Dictionary<string, float> dataFloat = new Dictionary<string,

float>();

public System.Action OnSave;

public System.Action OnLoad;

public override void OnAwake(){

SavePath = Path.Combine(Application.persistentDataPath, "Save");

Load();

Invoke("Save", 60);}

public bool ContainsInt(string key){

if (dataInt.ContainsKey(key))

return true;

return false;}

public bool ContainsFloat(string key){

if (dataFloat.ContainsKey(key))

return true;

return false;}

public void SaveAsInt(string key, int value){

if (dataInt.ContainsKey(key))

dataInt[key] = value;

else

dataInt.Add(key, value);}

public void SaveAsFloat(string key, float value){

if (dataFloat.ContainsKey(key))

dataFloat[key] = value;

else

dataFloat.Add(key, value);}

public int LoadAsInt(string key){

return dataInt[key];}

public float LoadAsFloat(string key){

return dataFloat[key];}

public bool LoadAsInt(string key, out int value){

value = 0;

if (!dataInt.ContainsKey(key)) return false;

value = dataInt[key];

return true;}

public bool LoadAsFloat(string key, out float value){

value = 0;

if (!dataFloat.ContainsKey(key)) return false;

value = dataFloat[key];

return true;}

public System.Action InitializeSavable(ISavable item){

OnSave += item.Save;

OnLoad += item.Load;

return delegate (){

OnSave -= item.Save;

OnLoad -= item.Load;};}

public void Save(){

OnSave?.Invoke();

Directory.CreateDirectory(SavePath);

File.WriteAllText(FullIntPath, JsonConvert.SerializeObject(dataInt,

Formatting.Indented));

File.WriteAllText(FullFloatPath, JsonConvert.SerializeObject(dataFloat,

Formatting.Indented));

Debug.Log($"Files saved to: {SavePath}");}

private void Load(){

OnLoad?.Invoke();

if (File.Exists(FullIntPath))

dataInt =

JsonConvert.DeserializeObject<Dictionary<string,

int>>(File.ReadAllText(FullIntPath));

if (File.Exists(FullFloatPath))

dataFloat =

JsonConvert.DeserializeObject<Dictionary<string,

float>>(File.ReadAllText(FullFloatPath));

Debug.Log($"Try load files from: {SavePath}");}

public void DeleteSave(){

File.Delete(FullIntPath);

File.Delete(FullFloatPath);}

private void OnApplicationFocus(bool focus){

if (focus) return;

Save();}}

SettingsController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class SettingsController : Controller{

public override void OnAwake(){

Application.targetFrameRate = Screen.currentResolution.refreshRate;}}

TimeController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class TimeController : Controller{

MusicController musicController;

LightController lightController;

void Start(){

musicController =

ControllerManager.GetInstance<StaticControllerManager>().GetController<

MusicController>();

lightController = ParentManager.GetController<LightController>();

InvokeRepeating("ChangeTime", 236, 236);}

public void ChangeTime(){

musicController.ChangeMusic();

lightController.SmoothChangeTime();}}

UIController.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class UIController : Controller{

[SerializeField] GameObject useButton;

[SerializeField] GameObject coinPanel;

[SerializeField] GameObject inventoryPanel;

[SerializeField] GameObject upgradePanel;

bool isCoinPanelShow;

bool isInventoryPanelShow;

bool isUpgradePanelShow;

public void ShowUseButton(){useButton.SetActive(true);}

public void HideUseButton(){useButton.SetActive(false);}

public void CheckCoinPanelHide(){

if (isInventoryPanelShow || isUpgradePanelShow)

return;

HideCoinPanel();}

public void ShowCoinPanel(){

coinPanel.SetActive(true);

isCoinPanelShow = true;}

public void HideCoinPanel(){

coinPanel.SetActive(false);

isCoinPanelShow = false;}

public void ShowInventoryPanel(){

inventoryPanel.SetActive(true);

isInventoryPanelShow = true;

HideUpgradePanel();

ShowCoinPanel();}

public void HideInventoryPanel(){

inventoryPanel.SetActive(false);

isInventoryPanelShow = false;

CheckCoinPanelHide();}

public void ShowUpgradePanel(){

upgradePanel.SetActive(true);

isUpgradePanelShow = true;

HideInventoryPanel();

ShowCoinPanel();}

public void HideUpgradePanel(){

upgradePanel.SetActive(false);

isUpgradePanelShow = false;

CheckCoinPanelHide();}

public void ReverseInventoryPanel(){

if (isInventoryPanelShow)

HideInventoryPanel();

else

ShowInventoryPanel();}

public void ReverseUpgradePanel(){

if (isUpgradePanelShow)

HideUpgradePanel();

else

ShowUpgradePanel();}}



Controller.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public abstract class Controller : MonoBehaviour{

#region[Key]

[SerializeField] private string _key;

public string Key => _key;

public void SetKey(string key) => _key = key;

#endregion

#region[ParentManager]

private ControllerManager _parentManager;

public ControllerManager ParentManager => _parentManager;

public T GetParentManager<T>() where T : ControllerManager =>

ParentManager as T;

public void SetParentManager(ControllerManager parent) =>

_parentManager = parent;

#endregion

#region[Unity Methods]

private void Awake(){OnAwake();}

private void Start(){

Initialize();

OnStart();}

private void OnEnable(){onEnable();}

private void OnDisable(){onDisable();}

private void OnDestroy(){

onDestroy();}

#endregion

#region[Overrides]

public virtual void OnStart() { }

public virtual void OnAwake() { }

public virtual void OnInitialize() { }

public virtual void onEnable() { }

public virtual void onDisable() { }

public virtual void onDestroy() { }

#endregion

private void Initialize()

{OnInitialize();}

public static T GetManager<T>() where T : ControllerManager =>

ControllerManager.GetInstance<T>();}

ControllerManager.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public delegate void ControllerManagerHandler();

public delegate void ControllerHandler(out bool isCorrect, Controller

controller);

public abstract class ControllerManager : MonoBehaviour{

[SerializeField] string key;

public string Key => key;

private static Dictionary<System.Type, List<ControllerManager>>

_instances = new Dictionary<System.Type, List<ControllerManager>>();

[SerializeField] private List<Controller> _controllers = new

List<Controller>();

public int CountControllers => _controllers.Count;

#region[Events]

protected event ControllerHandler OnAddController;

protected event ControllerManagerHandler PreAwakeEvent;

protected event ControllerManagerHandler OnAwakeEvent;

protected event ControllerManagerHandler OnStartEvent;

protected event ControllerManagerHandler OnUpdateEvent;

protected event ControllerManagerHandler OnFixedUpdateEvent;

#endregion

#region[Instance]

public static void AddInstance(ControllerManager controllerManager){

var type = controllerManager.GetType();

if (!_instances.ContainsKey(type))

_instances.Add(type, new List<ControllerManager>() { controllerManager

});

else

_instances[type].Add(controllerManager);}

public static void RemoveInstance(ControllerManager controllerManager){

var type = controllerManager.GetType();

if (!_instances.ContainsKey(type)) return;

_instances[type].Remove(controllerManager);

if (_instances[type].Count == 0)

_instances.Remove(type);}

public static T GetInstance<T>() where T : ControllerManager{

if (_instances.ContainsKey(typeof(T)))

return _instances[typeof(T)][0] as T;

return null;}

public static T GetInstance<T>(string key) where T : ControllerManager{

foreach (var instance in _instances.Values)

foreach (var instanceElement in instance)

if (instanceElement.Key.Equals(key))

return instanceElement as T;

return null;}

#endregion

#region[Unity Methods]

private void Awake(){

AddInstance(this);

PreAwake();

PreAwakeEvent?.Invoke();

var controllers = GetComponentsInChildren<Controller>();

foreach (var controller in controllers){

controller.SetParentManager(this);

AddController(controller);}

OnAwake();

OnAwakeEvent?.Invoke();}

private void Start(){

OnStartEvent?.Invoke();

OnStart();}

private void Update(){

OnUpdateEvent?.Invoke();

OnUpdate();}

private void FixedUpdate(){

OnFixedUpdateEvent?.Invoke();

OnFixedUpdate();}

#endregion

#region[Overrides]

public virtual void PreAwake() { }

public virtual void OnAwake() { }

public virtual void OnStart() { }

public virtual void OnUpdate() { }

public virtual void OnFixedUpdate() { }

#endregion

#region[Controllers]

public bool ControllerContains(Controller controller) =>

_controllers.Contains(controller);

public int GetControllerIndex(Controller controller){

for (int i = 0; i < _controllers.Count; i++)

if (ReferenceEquals(controller, _controllers[i]))

return i;

return -1;}

public string GetControllerKey(int index){

if (_controllers.Count - 1 < index)

return string.Empty;

return _controllers[index].Key;}

public T GetController<T>() where T : Controller{

foreach (var controller in _controllers)

if (controller is T con)

return con; return null;}

public T GetController<T>(System.Type t) where T : Controller{

foreach (var controller in _controllers)

if (controller.GetType() == t)

return controller as T;return null;}

public T GetController<T>(int index) where T : Controller {

if (_controllers.Count - 1 < index) return null;

return _controllers[index] as T;}

public T GetController<T>(out int index) where T : Controller{

for (int i = 0; i < _controllers.Count; i++){

if (_controllers[i] is T controller){index = i;return controller;}}

index = -1;

return null;}

public T GetController<T>(string key) where T : Controller{

foreach (var controller in _controllers)

if (controller.Key.Equals(key))

return controller as T;return null;}

public T GetController<T>(string key, out int index) where T : Controller{

for (int i = 0; i < _controllers.Count; i++){

if (_controllers[i].Key.Equals(key)){

index = i;

return _controllers[i] as T;}}

index = -1;

return null;}

public void ReplaceController<T>(Controller controller) where T :

Controller{

int index = 0;

var oldController = GetController<T>(out index);

if (index == -1)

return;

_controllers.RemoveAt(index);

_controllers.Insert(index, controller);}

public void ReplaceController<T>(string key, Controller controller) where T

: Controller{

int index = -1;

var oldController = GetController<Controller>(key, out index);

_controllers.RemoveAt(index);

_controllers.Insert(index, controller);}

public void ReplaceController<T>(Controller oldController, Controller

newController) where T : Controller{

int index = GetControllerIndex(oldController);

if (index == -1)

return;

_controllers.RemoveAt(index);

_controllers.Insert(index, newController); }

public List<T> GetControllers<T>() where T : Controller{

List<T> controllers = new List<T>();

foreach (var controller in _controllers)

if (controller is T con)

controllers.Add(con);

if (controllers.Count == 0)

return null;

return controllers;}

public List<T> GetControllers<T>(string key) where T : Controller{

List<T> controllers = new List<T>();

foreach (var controller in _controllers)

if (controller is T con && con.Key.Equals(key))

controllers.Add(con);

if (controllers.Count == 0)

return null;

return controllers;}

#region[AddController]

public bool AddController(GameObject controller){

Controller controllerComponent;

if (!TryGetComponent(out controllerComponent))

return false;

if (!_controllers.Contains(controllerComponent)){

bool isCorrect = true;

OnAddController?.Invoke(out isCorrect, controllerComponent);

if (isCorrect)

_controllers.Add(controllerComponent);}

controller.transform.parent = transform;

return true;}

public bool AddController(Controller controller){

if (!_controllers.Contains(controller)){

bool isCorrect = true;

OnAddController?.Invoke(out isCorrect, controller);

if (isCorrect)

_controllers.Add(controller);}

controller.transform.parent = transform;

return true;}

#endregion

#region[RemoveController]

public bool RemoveController(GameObject controller){

Controller controllerComponent;

if (!TryGetComponent(out controllerComponent))

return false;

if (!_controllers.Contains(controllerComponent))

return false;

_controllers.Remove(controllerComponent);

controller.transform.parent = null;

Destroy(controller.gameObject);

return true;}

public bool RemoveController(Controller controller){

if (!_controllers.Contains(controller))

return false;

_controllers.Remove(controller);

controller.transform.parent = null;

Destroy(controller.gameObject);

return true;}

#endregion

#endregion

}

StaticControllerManager.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class StaticControllerManager : ControllerManager{

public override void OnAwake(){

transform.parent = null;

DontDestroyOnLoad(gameObject);}}

CameraFollower.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class CameraFollower : MonoBehaviour{

public static CameraFollower instance;

private Camera _camera;

[SerializeField] Transform target;

[SerializeField] float speed = 0.1f;

[SerializeField] Vector2 offset;

[SerializeField] Corners _corners;

private void Start(){

_camera = GetComponent<Camera>();

instance = this;}

void FixedUpdate(){

if (!target) return;

Vector3 newPosition = new Vector3(

Mathf.Clamp(transform.position.x, _corners.LeftBorder,

_corners.RightBorder),

Mathf.Clamp(transform.position.y, _corners.BottomBorder,

_corners.TopBorder),

transform.position.z);

transform.position = Vector3.Lerp(newPosition, TargetPosition, speed);

ExecuteBorder(_corners._leftDownCorner);

ExecuteBorder(_corners._rightDownCorner);}

public void SetTarget(Transform target){

this.target = target;}

public Vector3 TargetPosition{

get{

Vector3 target = this.target.position;

return new Vector3(target.x, target.y, transform.position.z);}}

private void ExecuteBorder(Transform currentCornerPos){

var screenPoint = _camera.WorldToScreenPoint(currentCornerPos.position);

if (currentCornerPos.ToString().ToLower().Contains("left")){

if (screenPoint.x > 0){

Vector3 borderPosition =

_camera.ScreenToWorldPoint(new Vector3(screenPoint.x, 0, 0) + new

Vector3(Screen.width / 2f, 0f, 0f));

transform.position = new Vector3(borderPosition.x, transform.position.y,

transform.position.z);}

if (screenPoint.y > 0){

Vector3 borderPosition =

_camera.ScreenToWorldPoint(new Vector3(0, screenPoint.y, 0) + new

Vector3(0f, Screen.height / 2f, 0f));

transform.position = new Vector3(transform.position.x, borderPosition.y,

transform.position.z); }}

if (currentCornerPos.ToString().ToLower().Contains("right")){

if (screenPoint.x < Screen.width){

Vector3 borderPosition =

_camera.ScreenToWorldPoint(new Vector3(screenPoint.x, 0, 0) - new

Vector3(Screen.width / 2f, 0f, 0f));

transform.position = new Vector3(borderPosition.x, transform.position.y,

transform.position.z);}

if (screenPoint.y < Screen.height){

Vector3 borderPosition =

_camera.ScreenToWorldPoint(new Vector3(0, screenPoint.y, 0) - new

Vector3(0f, Screen.height / 2f, 0f));

transform.position = new Vector3(transform.position.x, borderPosition.y,

transform.position.z);}}}

[System.Serializable]

public class Corners{

[SerializeField] public Transform _leftDownCorner;

[SerializeField] public Transform _rightDownCorner;

public float LeftBorder => _leftDownCorner.position.x;

public float RightBorder => _rightDownCorner.position.x;

public float TopBorder => _rightDownCorner.position.y;

public float BottomBorder => _leftDownCorner.position.y;}}

Inventory.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class Inventory : MonoBehaviour, ISavable{

[SerializeField] int coins;

public int Coins => coins;

[SerializeField] List<Item> items = new List<Item>();

Dictionary<string, Item> itemsDict = new Dictionary<string, Item>();

PlayerController controller;

private void Start(){

controller = GetComponent<PlayerController>();

foreach (var item in items)

itemsDict.Add(item.Name, item);

saveController =

ControllerManager.GetInstance<StaticControllerManager>().GetController<

SaveController>();

onDestroy = saveController.InitializeSavable(this);

Load();}

public void AddCoins(int count){coins += count;}

public bool RemoveCoins(int count){

int decreasedCoins = coins - count;

if (decreasedCoins < 0)

return false;

coins = decreasedCoins;

return true;}

public void AddInItem(int count, string name){itemsDict[name].Count +=

count;}

public void SellItem(string name){

AddCoins(controller.plantController.plantsData[name].Price *

itemsDict[name].Count);

itemsDict[name].Count = 0;}

public int GetItemCount(string name) => itemsDict[name].Count;

private SaveController saveController;

private System.Action onDestroy;

public void Load(){

if (saveController.LoadAsInt("Inventory_Coin", out int coin))

coins = coin;

foreach (var item in itemsDict.Values){

if (saveController.LoadAsInt("Inventory_" + item.Name, out int count))

itemsDict[item.Name].Count = count;}}

public void Save(){

saveController.SaveAsInt("Inventory_Coin", coins);

foreach (var item in itemsDict.Values)

saveController.SaveAsInt("Inventory_" + item.Name, item.Count);}

public void OnDestroy(){onDestroy();}}



ISavable.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public interface ISavable{public void Load();public void Save();}

Item.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

[System.Serializable]

public class Item{public string Name;public int Count;}

Размещено на allbest.ru

...