You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
139 lines
5.3 KiB
139 lines
5.3 KiB
extends Node
|
|
|
|
signal next_quick_slot
|
|
signal previous_quick_slot
|
|
signal select_quick_slot(slot_index: int)
|
|
signal quick_slot_item_changed(item_id: String)
|
|
signal item_picked_up(item: DBItemResource)
|
|
signal item_dropped(item: DBItemResource)
|
|
signal inventory_opened
|
|
signal inventory_closed
|
|
|
|
signal add_to_inventory(item_id: String, amount: int)
|
|
signal remove_from_inventory(item_id: String, amount: int)
|
|
signal item_added(item_id: String, amount: int)
|
|
signal item_removed(item_id: String, amount: int)
|
|
|
|
var quick_slot_item_id: String = "001"
|
|
|
|
var max_inventory_items: int = 40 # 4 rows of 10
|
|
|
|
var inventory: Array[DBItemResource] = []
|
|
var _inventory_cache: Dictionary[String, Dictionary] = {} ## Used for caching certain information
|
|
|
|
func _ready() -> void:
|
|
self.quick_slot_item_changed.connect(_on_quick_slot_item_changed)
|
|
self.item_picked_up.connect(_on_item_picked_up)
|
|
self.item_dropped.connect(_on_item_dropped)
|
|
|
|
self.add_to_inventory.connect(_on_add_to_inventory)
|
|
self.remove_from_inventory.connect(_on_remove_from_inventory)
|
|
|
|
|
|
func available_space(item_id: String) -> int:
|
|
var full_stacks: int = floor(_inventory_cache[item_id].total / DBItems.data[item_id].max_stack_size)
|
|
var space_in_stacks: int = (
|
|
DBItems.data[item_id].max_stack_size - abs(
|
|
_inventory_cache[item_id].total - (DBItems.data[item_id].max_stack_size * full_stacks)
|
|
)
|
|
)
|
|
|
|
# This is a bit of a hack because I'm a math/logic noob
|
|
if space_in_stacks == DBItems.data[item_id].max_stack_size:
|
|
space_in_stacks = 0
|
|
|
|
var open_stack_amount: int = (max_inventory_items - inventory.size()) * DBItems.data[item_id].max_stack_size
|
|
return open_stack_amount + space_in_stacks
|
|
|
|
|
|
func _find_stacks_by_id(item_resource: DBItemResource, item_id: String) -> bool:
|
|
return item_resource.id == item_id
|
|
|
|
## Find the stack where at least one item can be added
|
|
func _find_stacks_with_space(item_resource: DBItemResource, item_id: String) -> bool:
|
|
return (
|
|
item_resource.id == item_id and
|
|
item_resource.amount < item_resource.max_stack_size
|
|
)
|
|
|
|
func _update_cache_total(item_id: String, amount: int) -> void:
|
|
if not _inventory_cache.get(item_id):
|
|
_inventory_cache[item_id] = {"total": 0}
|
|
_inventory_cache[item_id].total += amount
|
|
|
|
|
|
func _on_add_to_inventory(item_id: String, amount: int = 1) -> void:
|
|
if not DBItems.data.get(item_id):
|
|
printerr("Cannot add item, ", item_id, ", to inventory. Could not find item within DBItems.data.")
|
|
return
|
|
if amount < 1:
|
|
printerr("Cannot add item, ", item_id, ", to inventory. Amount to add cannot be less then 1.")
|
|
return
|
|
|
|
var item_resource: DBItemResource = DBItems.data[item_id]
|
|
|
|
# This logic seems overly complicated and is a mess.
|
|
# Should look into fixing/simplifying this in the future
|
|
var amount_remaining: int = amount
|
|
while amount_remaining > 0:
|
|
var first_stack_index: int = inventory.find_custom(_find_stacks_with_space.bind(item_id))
|
|
|
|
if first_stack_index == -1 and inventory.size() < max_inventory_items: # No existing stack and empty slots available
|
|
var stack_resource: DBItemResource = item_resource.duplicate()
|
|
inventory.append(stack_resource)
|
|
|
|
if amount_remaining <= stack_resource.max_stack_size:
|
|
_update_cache_total(item_id, amount_remaining)
|
|
inventory[-1].amount += amount_remaining
|
|
amount_remaining = 0
|
|
else:
|
|
_update_cache_total(item_id, stack_resource.max_stack_size)
|
|
inventory[-1].amount = stack_resource.max_stack_size
|
|
amount_remaining -= stack_resource.max_stack_size
|
|
elif first_stack_index > -1:
|
|
var stack_resource: DBItemResource = inventory[first_stack_index]
|
|
var current_amount: int = stack_resource.amount
|
|
var total_amount: int = current_amount + amount_remaining
|
|
if total_amount < stack_resource.max_stack_size: # Stack not full and has space
|
|
_update_cache_total(item_id, amount_remaining)
|
|
inventory[first_stack_index].amount = total_amount
|
|
amount_remaining = 0
|
|
else:
|
|
_update_cache_total(item_id, stack_resource.max_stack_size - current_amount)
|
|
inventory[first_stack_index].amount = stack_resource.max_stack_size
|
|
amount_remaining -= stack_resource.max_stack_size
|
|
|
|
item_added.emit(item_id, amount - amount_remaining)
|
|
|
|
func _on_remove_from_inventory(item_id: String, amount: int = 1) -> void:
|
|
var amount_remaining: int = amount
|
|
while amount_remaining > 0:
|
|
var last_stack_index: int = inventory.rfind_custom(_find_stacks_by_id.bind(item_id))
|
|
|
|
if last_stack_index > -1:
|
|
var stack_resource: DBItemResource = inventory[last_stack_index]
|
|
var current_stack_amount: int = stack_resource.amount
|
|
var total_amount: int = current_stack_amount - amount_remaining
|
|
|
|
if total_amount > 0: # Stack will not be empty after removing
|
|
_update_cache_total(item_id, -amount_remaining)
|
|
inventory[last_stack_index].amount -= amount_remaining
|
|
amount_remaining = 0
|
|
else:
|
|
var to_remove: int = stack_resource.max_stack_size - current_stack_amount
|
|
_update_cache_total(item_id, -amount_remaining)
|
|
inventory.remove_at(last_stack_index)
|
|
amount_remaining -= to_remove
|
|
else: # Received more to remove than we had stacks of
|
|
amount_remaining = 0
|
|
|
|
item_removed.emit(item_id, amount - amount_remaining)
|
|
|
|
func _on_item_dropped(item_id: String) -> void:
|
|
_on_remove_from_inventory(item_id, 1)
|
|
|
|
func _on_item_picked_up(item_id: String) -> void:
|
|
_on_add_to_inventory(item_id, 1)
|
|
|
|
func _on_quick_slot_item_changed(item_id: String) -> void:
|
|
quick_slot_item_id = item_id
|