519 lines
15 KiB
GDScript
519 lines
15 KiB
GDScript
class_name PlayerInventoryLayout
|
|
extends Node
|
|
|
|
const ItemCatalogType = preload("res://items/item_catalog.gd")
|
|
const ItemDataType = preload("res://items/item_data.gd")
|
|
const PlayerBagType = preload("res://inventory/player_bag.gd")
|
|
const FishInventoryType = preload("res://inventory/fish_inventory.gd")
|
|
const PlayerCoolerCapacityType = preload(
|
|
"res://progression/player_cooler_capacity.gd"
|
|
)
|
|
const PlayerWalletType = preload("res://economy/player_wallet.gd")
|
|
|
|
const INVENTORY_COLUMNS: int = 9
|
|
const INVENTORY_CAPACITIES: Array[int] = [9, 18, 27, 36]
|
|
const BACKPACK_EXPANSION_COSTS: Array[int] = [1500, 4500, 9000]
|
|
const MAX_BACKPACK_LEVEL: int = 3
|
|
const MAX_INVENTORY_SLOT_COUNT: int = 36
|
|
const MAX_STORAGE_SLOT_COUNT: int = PlayerCoolerCapacityType.MAX_CAPACITY
|
|
const HOTBAR_SLOT_COUNT: int = 9
|
|
|
|
enum EntryKind {
|
|
ITEM,
|
|
CATCH,
|
|
}
|
|
|
|
enum InventoryContainer {
|
|
INVENTORY,
|
|
STORAGE,
|
|
HOTBAR,
|
|
}
|
|
|
|
signal layout_changed
|
|
signal backpack_capacity_changed(level: int, capacity: int)
|
|
|
|
var _bag: PlayerBagType
|
|
var _fish_inventory: FishInventoryType
|
|
var _item_catalog: ItemCatalogType
|
|
var _storage_capacity: PlayerCoolerCapacityType
|
|
var _placements: Dictionary[String, Dictionary] = {}
|
|
var _reconciling: bool = false
|
|
var _backpack_level: int = 0
|
|
|
|
|
|
func setup(
|
|
bag: PlayerBagType,
|
|
fish_inventory: FishInventoryType,
|
|
item_catalog: ItemCatalogType,
|
|
storage_capacity: PlayerCoolerCapacityType,
|
|
) -> void:
|
|
_bag = bag
|
|
_fish_inventory = fish_inventory
|
|
_item_catalog = item_catalog
|
|
_storage_capacity = storage_capacity
|
|
if _bag != null and not _bag.contents_changed.is_connected(_on_contents_changed):
|
|
_bag.contents_changed.connect(_on_contents_changed)
|
|
if (
|
|
_fish_inventory != null
|
|
and not _fish_inventory.catches_changed.is_connected(_on_contents_changed)
|
|
):
|
|
_fish_inventory.catches_changed.connect(_on_contents_changed)
|
|
if (
|
|
_storage_capacity != null
|
|
and not _storage_capacity.capacity_changed.is_connected(
|
|
_on_storage_capacity_changed
|
|
)
|
|
):
|
|
_storage_capacity.capacity_changed.connect(_on_storage_capacity_changed)
|
|
_reconcile(true)
|
|
|
|
|
|
func can_accept_item(item_id: StringName) -> bool:
|
|
if not is_managed_item(item_id):
|
|
return true
|
|
var key := item_key(item_id)
|
|
return _placements.has(key) or _first_free_slot(InventoryContainer.INVENTORY) >= 0
|
|
|
|
|
|
func can_accept_catch(catch_id: StringName = StringName()) -> bool:
|
|
if not catch_id.is_empty() and _placements.has(catch_key(catch_id)):
|
|
return true
|
|
return _first_free_slot(InventoryContainer.INVENTORY) >= 0
|
|
|
|
|
|
func is_managed_item(item_id: StringName) -> bool:
|
|
var item: ItemDataType = (
|
|
_item_catalog.get_item_by_id(item_id)
|
|
if _item_catalog != null else null
|
|
)
|
|
return item != null and not item.is_bait() and not item.is_lure()
|
|
|
|
|
|
func is_item_in_inventory(item_id: StringName) -> bool:
|
|
return _is_entry_in_container(item_key(item_id), InventoryContainer.INVENTORY)
|
|
|
|
|
|
func is_catch_in_inventory(catch_id: StringName) -> bool:
|
|
return _is_entry_in_container(catch_key(catch_id), InventoryContainer.INVENTORY)
|
|
|
|
|
|
func is_item_carried(item_id: StringName) -> bool:
|
|
return _is_entry_carried(item_key(item_id))
|
|
|
|
|
|
func is_catch_carried(catch_id: StringName) -> bool:
|
|
return _is_entry_carried(catch_key(catch_id))
|
|
|
|
|
|
func get_inventory_count() -> int:
|
|
return get_entries(InventoryContainer.INVENTORY).size()
|
|
|
|
|
|
func get_inventory_capacity() -> int:
|
|
return INVENTORY_CAPACITIES[_backpack_level]
|
|
|
|
|
|
func get_backpack_level() -> int:
|
|
return _backpack_level
|
|
|
|
|
|
func get_next_inventory_capacity() -> int:
|
|
if _backpack_level >= MAX_BACKPACK_LEVEL:
|
|
return -1
|
|
return INVENTORY_CAPACITIES[_backpack_level + 1]
|
|
|
|
|
|
func get_next_backpack_cost() -> int:
|
|
if _backpack_level >= MAX_BACKPACK_LEVEL:
|
|
return -1
|
|
return BACKPACK_EXPANSION_COSTS[_backpack_level]
|
|
|
|
|
|
func can_purchase_backpack(wallet: PlayerWalletType) -> bool:
|
|
var cost := get_next_backpack_cost()
|
|
return wallet != null and cost >= 0 and wallet.can_afford(cost)
|
|
|
|
|
|
func purchase_backpack(wallet: PlayerWalletType) -> bool:
|
|
if not can_purchase_backpack(wallet):
|
|
return false
|
|
var cost := get_next_backpack_cost()
|
|
if not wallet.debit(cost):
|
|
return false
|
|
_backpack_level += 1
|
|
backpack_capacity_changed.emit(_backpack_level, get_inventory_capacity())
|
|
layout_changed.emit()
|
|
return true
|
|
|
|
|
|
func restore_backpack_level(level: int) -> bool:
|
|
var validated := clampi(level, 0, MAX_BACKPACK_LEVEL)
|
|
var changed := _backpack_level != validated
|
|
_backpack_level = validated
|
|
if changed:
|
|
backpack_capacity_changed.emit(_backpack_level, get_inventory_capacity())
|
|
_reconcile(changed)
|
|
return true
|
|
|
|
|
|
func get_storage_count() -> int:
|
|
return get_entries(InventoryContainer.STORAGE).size()
|
|
|
|
|
|
func get_hotbar_count() -> int:
|
|
return get_entries(InventoryContainer.HOTBAR).size()
|
|
|
|
|
|
func get_storage_capacity() -> int:
|
|
return _storage_capacity.get_capacity() if _storage_capacity != null else 0
|
|
|
|
|
|
func get_entries(container: InventoryContainer) -> Array[Dictionary]:
|
|
var entries: Array[Dictionary] = []
|
|
for key: String in _placements:
|
|
var placement: Dictionary = _placements[key]
|
|
if int(placement.get("container", -1)) != int(container):
|
|
continue
|
|
var entry: Dictionary = placement.duplicate(true)
|
|
entry["key"] = key
|
|
entries.append(entry)
|
|
entries.sort_custom(
|
|
func(left: Dictionary, right: Dictionary) -> bool:
|
|
return int(left.get("slot", -1)) < int(right.get("slot", -1))
|
|
)
|
|
return entries
|
|
|
|
|
|
func get_entry(kind: EntryKind, identity: StringName) -> Dictionary:
|
|
var key := _entry_key(kind, identity)
|
|
return _placements.get(key, {}).duplicate(true)
|
|
|
|
|
|
func get_container(kind: EntryKind, identity: StringName) -> int:
|
|
return int(
|
|
get_entry(kind, identity).get("container", -1)
|
|
)
|
|
|
|
|
|
func get_key_at(container: InventoryContainer, slot: int) -> String:
|
|
return _key_at(container, slot)
|
|
|
|
|
|
func get_entry_at(container: InventoryContainer, slot: int) -> Dictionary:
|
|
var key := _key_at(container, slot)
|
|
if key.is_empty():
|
|
return {}
|
|
var entry: Dictionary = _placements[key].duplicate(true)
|
|
entry["key"] = key
|
|
return entry
|
|
|
|
|
|
func move_entry(
|
|
kind: EntryKind,
|
|
identity: StringName,
|
|
target_container: InventoryContainer,
|
|
target_slot: int,
|
|
) -> bool:
|
|
var key := _entry_key(kind, identity)
|
|
if not _placements.has(key) or not _is_slot_valid(target_container, target_slot):
|
|
return false
|
|
var source: Dictionary = _placements[key]
|
|
if (
|
|
int(source.get("container", -1)) == int(target_container)
|
|
and int(source.get("slot", -1)) == target_slot
|
|
):
|
|
return true
|
|
var displaced_key := _key_at(target_container, target_slot)
|
|
var source_container: int = int(source.get("container", InventoryContainer.INVENTORY))
|
|
var source_slot: int = int(source.get("slot", -1))
|
|
source["container"] = int(target_container)
|
|
source["slot"] = target_slot
|
|
_placements[key] = source
|
|
if not displaced_key.is_empty():
|
|
var displaced: Dictionary = _placements[displaced_key]
|
|
displaced["container"] = source_container
|
|
displaced["slot"] = source_slot
|
|
_placements[displaced_key] = displaced
|
|
layout_changed.emit()
|
|
return true
|
|
|
|
|
|
func move_entry_to_first_free(
|
|
kind: EntryKind,
|
|
identity: StringName,
|
|
target_container: InventoryContainer,
|
|
) -> bool:
|
|
var slot := _first_free_slot(target_container)
|
|
return slot >= 0 and move_entry(kind, identity, target_container, slot)
|
|
|
|
|
|
func return_hotbar_entry_to_inventory(slot: int) -> bool:
|
|
var key := _key_at(InventoryContainer.HOTBAR, slot)
|
|
if key.is_empty():
|
|
return true
|
|
var placement: Dictionary = _placements[key]
|
|
return move_entry_to_first_free(
|
|
int(placement.get("kind", -1)) as EntryKind,
|
|
StringName(str(placement.get("identity", ""))),
|
|
InventoryContainer.INVENTORY,
|
|
)
|
|
|
|
|
|
func return_all_hotbar_entries_to_inventory() -> bool:
|
|
var entries := get_entries(InventoryContainer.HOTBAR)
|
|
if get_inventory_count() + entries.size() > get_inventory_capacity():
|
|
return false
|
|
for entry: Dictionary in entries:
|
|
if not move_entry_to_first_free(
|
|
int(entry.get("kind", -1)) as EntryKind,
|
|
StringName(str(entry.get("identity", ""))),
|
|
InventoryContainer.INVENTORY,
|
|
):
|
|
return false
|
|
return true
|
|
|
|
|
|
func to_save_data() -> Dictionary:
|
|
var serialized: Array[Dictionary] = []
|
|
var keys: Array[String] = []
|
|
keys.assign(_placements.keys())
|
|
keys.sort()
|
|
for key: String in keys:
|
|
var placement: Dictionary = _placements[key]
|
|
serialized.append({
|
|
"kind": int(placement.get("kind", EntryKind.ITEM)),
|
|
"identity": str(placement.get("identity", "")),
|
|
"container": int(placement.get("container", InventoryContainer.INVENTORY)),
|
|
"slot": int(placement.get("slot", -1)),
|
|
})
|
|
return {
|
|
"backpack_level": _backpack_level,
|
|
"placements": serialized,
|
|
}
|
|
|
|
|
|
func restore_from_save_data(data: Dictionary) -> bool:
|
|
var level_value: Variant = data.get("backpack_level", 0)
|
|
if (
|
|
typeof(level_value) not in [TYPE_INT, TYPE_FLOAT]
|
|
or not is_equal_approx(float(level_value), floorf(float(level_value)))
|
|
):
|
|
return false
|
|
_backpack_level = clampi(int(level_value), 0, MAX_BACKPACK_LEVEL)
|
|
var restored: Dictionary[String, Dictionary] = {}
|
|
var values: Variant = data.get("placements", [])
|
|
if typeof(values) != TYPE_ARRAY:
|
|
return false
|
|
for value: Variant in values as Array:
|
|
if typeof(value) != TYPE_DICTIONARY:
|
|
continue
|
|
var record := value as Dictionary
|
|
var kind: int = int(record.get("kind", -1))
|
|
var identity := StringName(str(record.get("identity", "")))
|
|
var container: int = int(record.get("container", -1))
|
|
var slot: int = int(record.get("slot", -1))
|
|
if (
|
|
kind not in [EntryKind.ITEM, EntryKind.CATCH]
|
|
or identity.is_empty()
|
|
or container not in [
|
|
InventoryContainer.INVENTORY,
|
|
InventoryContainer.STORAGE,
|
|
InventoryContainer.HOTBAR,
|
|
]
|
|
or not _is_slot_valid(container as InventoryContainer, slot)
|
|
):
|
|
continue
|
|
var key := _entry_key(kind as EntryKind, identity)
|
|
if restored.has(key) or _placement_slot_occupied(restored, container, slot):
|
|
continue
|
|
restored[key] = {
|
|
"kind": kind,
|
|
"identity": identity,
|
|
"container": container,
|
|
"slot": slot,
|
|
}
|
|
_placements = restored
|
|
_reconcile(true)
|
|
return true
|
|
|
|
|
|
func reset_to_defaults() -> void:
|
|
var capacity_changed := _backpack_level != 0
|
|
_backpack_level = 0
|
|
_placements.clear()
|
|
_reconcile(true)
|
|
if capacity_changed:
|
|
backpack_capacity_changed.emit(_backpack_level, get_inventory_capacity())
|
|
|
|
|
|
static func item_key(item_id: StringName) -> String:
|
|
return "item:%s" % String(item_id)
|
|
|
|
|
|
static func catch_key(catch_id: StringName) -> String:
|
|
return "catch:%s" % String(catch_id)
|
|
|
|
|
|
func _entry_key(kind: EntryKind, identity: StringName) -> String:
|
|
return item_key(identity) if kind == EntryKind.ITEM else catch_key(identity)
|
|
|
|
|
|
func _is_entry_in_container(key: String, container: InventoryContainer) -> bool:
|
|
var placement: Dictionary = _placements.get(key, {})
|
|
return int(placement.get("container", -1)) == int(container)
|
|
|
|
|
|
func _is_entry_carried(key: String) -> bool:
|
|
var placement: Dictionary = _placements.get(key, {})
|
|
var container: int = int(placement.get("container", -1))
|
|
return container in [InventoryContainer.INVENTORY, InventoryContainer.HOTBAR]
|
|
|
|
|
|
func _on_contents_changed() -> void:
|
|
_reconcile(false)
|
|
|
|
|
|
func _on_storage_capacity_changed(_level: int, _capacity: int) -> void:
|
|
_reconcile(true)
|
|
|
|
|
|
func _reconcile(force_signal: bool) -> void:
|
|
if _reconciling or _bag == null or _fish_inventory == null:
|
|
return
|
|
_reconciling = true
|
|
var expected: Dictionary[String, Dictionary] = {}
|
|
for owned in _bag.get_all_items():
|
|
if owned == null or not is_managed_item(owned.item_id):
|
|
continue
|
|
var key := item_key(owned.item_id)
|
|
expected[key] = {"kind": EntryKind.ITEM, "identity": owned.item_id}
|
|
for fish_catch in _fish_inventory.get_all_catches():
|
|
if fish_catch == null or not fish_catch.is_valid():
|
|
continue
|
|
var key := catch_key(fish_catch.catch_id)
|
|
expected[key] = {"kind": EntryKind.CATCH, "identity": fish_catch.catch_id}
|
|
var changed: bool = false
|
|
for key: String in _placements.keys():
|
|
if expected.has(key):
|
|
continue
|
|
_placements.erase(key)
|
|
changed = true
|
|
_normalize_existing_placements()
|
|
for key: String in expected:
|
|
if _placements.has(key):
|
|
continue
|
|
var target_container := InventoryContainer.INVENTORY
|
|
var target_slot := _first_free_slot(target_container)
|
|
if target_slot < 0:
|
|
target_container = InventoryContainer.STORAGE
|
|
target_slot = _first_free_slot(target_container)
|
|
if target_slot < 0:
|
|
push_error("Inventory and storage cannot fit owned entry '%s'." % key)
|
|
continue
|
|
var placement: Dictionary = expected[key].duplicate(true)
|
|
placement["container"] = int(target_container)
|
|
placement["slot"] = target_slot
|
|
_placements[key] = placement
|
|
changed = true
|
|
_reconciling = false
|
|
if changed or force_signal:
|
|
layout_changed.emit()
|
|
|
|
|
|
func _normalize_existing_placements() -> void:
|
|
var occupied_inventory: Dictionary[int, bool] = {}
|
|
var occupied_storage: Dictionary[int, bool] = {}
|
|
var occupied_hotbar: Dictionary[int, bool] = {}
|
|
var invalid_keys: Array[String] = []
|
|
var keys: Array[String] = []
|
|
keys.assign(_placements.keys())
|
|
keys.sort()
|
|
for key: String in keys:
|
|
var placement: Dictionary = _placements[key]
|
|
var container: int = int(placement.get("container", -1))
|
|
var slot: int = int(placement.get("slot", -1))
|
|
var occupied: Dictionary[int, bool]
|
|
match container:
|
|
InventoryContainer.INVENTORY:
|
|
occupied = occupied_inventory
|
|
InventoryContainer.STORAGE:
|
|
occupied = occupied_storage
|
|
InventoryContainer.HOTBAR:
|
|
occupied = occupied_hotbar
|
|
_:
|
|
occupied = {}
|
|
if (
|
|
container not in [
|
|
InventoryContainer.INVENTORY,
|
|
InventoryContainer.STORAGE,
|
|
InventoryContainer.HOTBAR,
|
|
]
|
|
or not _is_slot_valid(container as InventoryContainer, slot)
|
|
or occupied.has(slot)
|
|
):
|
|
invalid_keys.append(key)
|
|
continue
|
|
occupied[slot] = true
|
|
for key: String in invalid_keys:
|
|
# Invalid records must stop occupying their old slot before free-space
|
|
# lookup. Otherwise a duplicate can incorrectly reserve a valid slot.
|
|
var placement: Dictionary = _placements[key]
|
|
_placements.erase(key)
|
|
var target := InventoryContainer.INVENTORY
|
|
var slot := _first_free_slot(target)
|
|
if slot < 0:
|
|
target = InventoryContainer.STORAGE
|
|
slot = _first_free_slot(target)
|
|
if slot < 0:
|
|
_placements.erase(key)
|
|
continue
|
|
placement["container"] = int(target)
|
|
placement["slot"] = slot
|
|
_placements[key] = placement
|
|
|
|
|
|
func _first_free_slot(container: InventoryContainer) -> int:
|
|
var capacity := (
|
|
get_inventory_capacity() if container == InventoryContainer.INVENTORY
|
|
else HOTBAR_SLOT_COUNT if container == InventoryContainer.HOTBAR
|
|
else get_storage_capacity()
|
|
)
|
|
for slot: int in capacity:
|
|
if _key_at(container, slot).is_empty():
|
|
return slot
|
|
return -1
|
|
|
|
|
|
func _key_at(container: InventoryContainer, slot: int) -> String:
|
|
for key: String in _placements:
|
|
var placement: Dictionary = _placements[key]
|
|
if (
|
|
int(placement.get("container", -1)) == int(container)
|
|
and int(placement.get("slot", -1)) == slot
|
|
):
|
|
return key
|
|
return ""
|
|
|
|
|
|
func _is_slot_valid(container: InventoryContainer, slot: int) -> bool:
|
|
if slot < 0:
|
|
return false
|
|
return slot < (
|
|
get_inventory_capacity() if container == InventoryContainer.INVENTORY
|
|
else HOTBAR_SLOT_COUNT if container == InventoryContainer.HOTBAR
|
|
else get_storage_capacity()
|
|
)
|
|
|
|
|
|
func _placement_slot_occupied(
|
|
placements: Dictionary[String, Dictionary],
|
|
container: int,
|
|
slot: int,
|
|
) -> bool:
|
|
for placement: Dictionary in placements.values():
|
|
if (
|
|
int(placement.get("container", -1)) == container
|
|
and int(placement.get("slot", -1)) == slot
|
|
):
|
|
return true
|
|
return false
|