forked from woofmeow/straywild
Add gathering, unified inventory, and real-time world
This commit is contained in:
parent
173371e6fc
commit
fa57edca83
113 changed files with 6700 additions and 1307 deletions
519
inventory/player_inventory_layout.gd
Normal file
519
inventory/player_inventory_layout.gd
Normal file
|
|
@ -0,0 +1,519 @@
|
|||
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
|
||||
Loading…
Add table
Add a link
Reference in a new issue