core/src/ru/deadsoftware/cavedroid/game/mobs/player/Inventory.kt

   1 package ru.deadsoftware.cavedroid.game.mobs.player
   2
   3 import ru.deadsoftware.cavedroid.game.GameItemsHolder
   4 import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
   5 import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
   6 import ru.deadsoftware.cavedroid.game.model.item.Item
   7 import ru.deadsoftware.cavedroid.game.objects.drop.Drop
   8 import ru.deadsoftware.cavedroid.game.ui.TooltipManager
   9 import ru.deadsoftware.cavedroid.misc.Saveable
  10
  11 class Inventory @JvmOverloads constructor(
  12     val size: Int,
  13     val hotbarSize: Int,
  14     gameItemsHolder: GameItemsHolder,
  15     tooltipManager: TooltipManager,
  16     initialItems: List<InventoryItem>? = null
  17 ) : Saveable {
  18
  19     @Suppress("UNNECESSARY_LATEINIT")
  20     private lateinit var tooltipManager: TooltipManager
  21
  22     @Suppress("UNNECESSARY_LATEINIT")
  23     private lateinit var fallbackItem: InventoryItem
  24
  25     private val _items: Array<InventoryItem>
  26
  27     init {
  28         fallbackItem = gameItemsHolder.fallbackItem.toInventoryItem()
  29         this.tooltipManager = tooltipManager
  30
  31         if (size < 0 || hotbarSize < 0 || hotbarSize > size) {
  32             throw IllegalArgumentException("Invalid inventory sizes: hotbarSize=$hotbarSize; size=$size")
  33         }
  34
  35         _items = Array(size) { index -> initialItems?.getOrNull(index) ?: InventoryItem(gameItemsHolder.fallbackItem) }
  36     }
  37
  38     val items get() = _items.asList() as MutableList<InventoryItem>
  39
  40     val hotbarItems get() = items.subList(0, hotbarSize)
  41
  42     private var _activeSlot = 0
  43
  44     var activeSlot
  45         get() = _activeSlot
  46         set(value) {
  47             if (value in 0 ..< hotbarSize) {
  48                 _activeSlot = value
  49                 showCurrentItemTooltip()
  50             }
  51         }
  52
  53     fun showCurrentItemTooltip() {
  54         tooltipManager.showHotbarTooltip(activeItem.item.params.name)
  55     }
  56
  57     val activeItem get() = _items[activeSlot]
  58
  59     fun initItems(gameItemsHolder: GameItemsHolder, tooltipManager: TooltipManager) {
  60         this.tooltipManager = tooltipManager
  61         fallbackItem = gameItemsHolder.fallbackItem.toInventoryItem()
  62         _items.forEach { item ->
  63             item.init(gameItemsHolder)
  64         }
  65     }
  66
  67     private fun getItemPickSlot(drop: Drop): Int {
  68         val item = drop.item
  69
  70         for (i in _items.indices) {
  71             val inventoryItem = _items[i]
  72
  73             if (item == inventoryItem.item && inventoryItem.canBeAdded()) {
  74                 return i
  75             }
  76         }
  77
  78         for (i in _items.indices) {
  79             val inventoryItem = _items[i]
  80
  81             if (inventoryItem.item.isNone()) {
  82                 return i
  83             }
  84         }
  85
  86         return -1
  87     }
  88
  89     fun canPickItem(drop: Drop): Boolean {
  90         return getItemPickSlot(drop) >= 0
  91     }
  92
  93     fun pickDrop(drop: Drop) {
  94         val slot = getItemPickSlot(drop).takeIf { it >= 0 } ?: return
  95         val inventoryItem = _items[slot]
  96
  97         if (inventoryItem.item == drop.item) {
  98             if (inventoryItem.canBeAdded(drop.amount)) {
  99                 inventoryItem.add(drop.amount)
 100                 drop.pickedUp = true
 101             } else {
 102                 val addCount = inventoryItem.item.params.maxStack - inventoryItem.amount
 103                 inventoryItem.add(addCount)
 104                 drop.subtract(addCount)
 105                 pickDrop(drop)
 106             }
 107         } else {
 108             _items[slot] = drop.item.toInventoryItem(drop.amount)
 109             if (slot == activeSlot) {
 110                 showCurrentItemTooltip()
 111             }
 112             drop.pickedUp = true
 113         }
 114     }
 115
 116     fun addItem(item: Item) {
 117         _items.copyInto(
 118             destination = _items,
 119             destinationOffset = 1,
 120             startIndex = 0,
 121             endIndex = size - 1
 122         )
 123
 124         _items[0] = item.toInventoryItem(item.params.maxStack)
 125         showCurrentItemTooltip()
 126     }
 127
 128     @JvmOverloads
 129     fun decreaseItemAmount(slot: Int, count: Int = 1) {
 130         val item = _items[slot]
 131         item.subtract(count)
 132         if (item.amount <= 0) {
 133             _items[slot] = fallbackItem
 134         }
 135     }
 136
 137     @JvmOverloads
 138     fun decreaseCurrentItemAmount(count: Int = 1) {
 139         decreaseItemAmount(activeSlot, count)
 140     }
 141
 142     fun clear() {
 143         for (i in _items.indices) {
 144             _items[i] = fallbackItem
 145         }
 146     }
 147
 148     override fun getSaveData(): SaveDataDto.InventorySaveData {
 149         return SaveDataDto.InventorySaveData(
 150             version = SAVE_DATA_VERSION,
 151             size = size,
 152             hotbarSize = hotbarSize,
 153             activeSlot = _activeSlot,
 154             items = items.map(InventoryItem::getSaveData)
 155         )
 156     }
 157
 158     companion object {
 159         private const val SAVE_DATA_VERSION = 1
 160
 161         fun fromSaveData(
 162             saveData: SaveDataDto.InventorySaveData,
 163             gameItemsHolder: GameItemsHolder,
 164             tooltipManager: TooltipManager,
 165         ): Inventory {
 166             saveData.verifyVersion(SAVE_DATA_VERSION)
 167
 168             return Inventory(
 169                 size = saveData.size,
 170                 hotbarSize = saveData.hotbarSize,
 171                 gameItemsHolder = gameItemsHolder,
 172                 tooltipManager = tooltipManager,
 173                 initialItems = saveData.items.map { item -> InventoryItem.fromSaveData(item, gameItemsHolder) }
 174             ).apply {
 175                 _activeSlot = saveData.activeSlot
 176             }
 177         }
 178     }
 179 }