UnityRPG/Assets/_Project/Scripts/Infrastructure/Save/PlayerItemSaveAdapter.cs at main · ChoDoGyu/UnityRPG · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityRPG.Item;

namespace UnityRPG.Infrastructure.Save
{
    [DisallowMultipleComponent]
    [RequireComponent(typeof(PlayerInventory))]
    [RequireComponent(typeof(PlayerEquipment))]
    [RequireComponent(typeof(PlayerEquipmentController))]
    public sealed class PlayerItemSaveAdapter : MonoBehaviour
    {
        [SerializeField] private ItemDatabase itemDatabase;

        private PlayerInventory inventory;
        private PlayerEquipment equipment;
        private PlayerEquipmentController equipmentController;

        private void Awake()
        {
            inventory = GetComponent<PlayerInventory>();
            equipment = GetComponent<PlayerEquipment>();
            equipmentController = GetComponent<PlayerEquipmentController>();
        }

        public bool Capture(SaveGameData data)
        {
            if (data == null || data.inventory == null || data.equipment == null)
                return false;

            data.inventory.Clear();
            data.equipment.Clear();

            for (int i = 0; i < inventory.Slots.Count; i++)
            {
                InventorySlot slot = inventory.Slots[i];

                data.inventory.Add(new InventoryItemSaveData
                {
                    itemId = slot.Item.ItemId,
                    count = slot.Count
                });
            }

            foreach (EquipmentSlot slot in Enum.GetValues(typeof(EquipmentSlot)))
            {
                EquipmentDefinition item = equipment.GetEquipped(slot);

                if (item == null)
                    continue;

                data.equipment.Add(new EquipmentSaveData
                {
                    slot = slot.ToString(),
                    itemId = item.ItemId
                });
            }

            return true;
        }

        public bool Restore(SaveGameData data)
        {
            if (data == null || itemDatabase == null)
                return false;

            if (!ValidateInventoryData(data.inventory) || !ValidateEquipmentData(data.equipment))
                return false;

            equipmentController.ClearForRestore();
            inventory.Clear();

            for (int i = 0; i < data.inventory.Count; i++)
            {
                InventoryItemSaveData saveItem = data.inventory[i];
                itemDatabase.TryGetItem(saveItem.itemId, out ItemDefinition item);

                if (inventory.AddItem(item, saveItem.count) != saveItem.count)
                    return false;
            }

            for (int i = 0; i < data.equipment.Count; i++)
            {
                EquipmentSaveData saveEquipment = data.equipment[i];
                itemDatabase.TryGetItem(saveEquipment.itemId, out ItemDefinition item);

                if (!equipmentController.TryEquipForRestore((EquipmentDefinition)item))
                    return false;
            }

            return true;
        }

        private bool ValidateInventoryData(List<InventoryItemSaveData> saveItems)
        {
            if (saveItems == null || saveItems.Count > inventory.MaxSlots)
                return false;

            for (int i = 0; i < saveItems.Count; i++)
            {
                InventoryItemSaveData saveItem = saveItems[i];

                if (saveItem == null || !itemDatabase.TryGetItem(saveItem.itemId, out ItemDefinition item))
                    return false;

                if (saveItem.count < 1 || saveItem.count > item.MaxStack)
                    return false;
            }

            return true;
        }

        private bool ValidateEquipmentData(List<EquipmentSaveData> saveEquipment)
        {
            if (saveEquipment == null)
                return false;

            HashSet<EquipmentSlot> usedSlots = new();

            for (int i = 0; i < saveEquipment.Count; i++)
            {
                EquipmentSaveData entry = saveEquipment[i];

                if (entry == null || !Enum.TryParse(entry.slot, out EquipmentSlot slot) || !usedSlots.Add(slot))
                    return false;

                if (!itemDatabase.TryGetItem(entry.itemId, out ItemDefinition item))
                    return false;

                if (item is not EquipmentDefinition equipmentItem || equipmentItem.Slot != slot)
                    return false;
            }

            return true;
        }
    }
}