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.item.InventoryItem
   5 import ru.deadsoftware.cavedroid.game.model.item.Item
   6 import ru.deadsoftware.cavedroid.game.objects.drop.Drop
   7 import ru.deadsoftware.cavedroid.game.ui.TooltipManager
   8 import java.io.Serializable
   9
  10 class Inventory(
  11     val size: Int,
  12     val hotbarSize: Int,
  13     gameItemsHolder: GameItemsHolder,
  14     tooltipManager: TooltipManager,
  15 ) : Serializable {
  16
  17     @Suppress("UNNECESSARY_LATEINIT")
  18     @Transient
  19     private lateinit var tooltipManager: TooltipManager
  20
  21     @Suppress("UNNECESSARY_LATEINIT")
  22     @Transient
  23     private lateinit var fallbackItem: InventoryItem
  24
  25     init {
  26         fallbackItem = gameItemsHolder.fallbackItem.toInventoryItem()
  27         this.tooltipManager = tooltipManager
  28
  29         if (size < 0 || hotbarSize < 0 || hotbarSize > size) {
  30             throw IllegalArgumentException("Invalid inventory sizes: hotbarSize=$hotbarSize; size=$size")
  31         }
  32     }
  33
  34     private val _items = Array(size) { InventoryItem(gameItemsHolder.fallbackItem) }
  35
  36     val items get() = _items.asList() as MutableList<InventoryItem>
  37
  38     val hotbarItems get() = items.subList(0, hotbarSize)
  39
  40     var activeSlot = 0
  41         set(value) {
  42             if (value in 0 ..< hotbarSize) {
  43                 field = value
  44                 showCurrentItemTooltip()
  45             }
  46         }
  47
  48     fun showCurrentItemTooltip() {
  49         tooltipManager.showHotbarTooltip(activeItem.item.params.name)
  50     }
  51
  52     val activeItem get() = _items[activeSlot]
  53
  54     fun initItems(gameItemsHolder: GameItemsHolder, tooltipManager: TooltipManager) {
  55         this.tooltipManager = tooltipManager
  56         fallbackItem = gameItemsHolder.fallbackItem.toInventoryItem()
  57         _items.forEach { item ->
  58             item.init(gameItemsHolder)
  59         }
  60     }
  61
  62     private fun getItemPickSlot(drop: Drop): Int {
  63         val item = drop.item
  64
  65         for (i in _items.indices) {
  66             val inventoryItem = _items[i]
  67
  68             if (item == inventoryItem.item && inventoryItem.canBeAdded()) {
  69                 return i
  70             }
  71         }
  72
  73         for (i in _items.indices) {
  74             val inventoryItem = _items[i]
  75
  76             if (inventoryItem.item.isNone()) {
  77                 return i
  78             }
  79         }
  80
  81         return -1
  82     }
  83
  84     fun canPickItem(drop: Drop): Boolean {
  85         return getItemPickSlot(drop) >= 0
  86     }
  87
  88     fun pickDrop(drop: Drop) {
  89         val slot = getItemPickSlot(drop).takeIf { it >= 0 } ?: return
  90         val inventoryItem = _items[slot]
  91
  92         if (inventoryItem.item == drop.item) {
  93             if (inventoryItem.canBeAdded(drop.amount)) {
  94                 inventoryItem.add(drop.amount)
  95                 drop.pickedUp = true
  96             } else {
  97                 val addCount = inventoryItem.item.params.maxStack - inventoryItem.amount
  98                 inventoryItem.add(addCount)
  99                 drop.subtract(addCount)
 100                 pickDrop(drop)
 101             }
 102         } else {
 103             _items[slot] = drop.item.toInventoryItem(drop.amount)
 104             if (slot == activeSlot) {
 105                 showCurrentItemTooltip()
 106             }
 107             drop.pickedUp = true
 108         }
 109     }
 110
 111     fun addItem(item: Item) {
 112         _items.copyInto(
 113             destination = _items,
 114             destinationOffset = 1,
 115             startIndex = 0,
 116             endIndex = size - 1
 117         )
 118
 119         _items[0] = item.toInventoryItem(item.params.maxStack)
 120         showCurrentItemTooltip()
 121     }
 122
 123     @JvmOverloads
 124     fun decreaseItemAmount(slot: Int, count: Int = 1) {
 125         val item = _items[slot]
 126         item.subtract(count)
 127         if (item.amount <= 0) {
 128             _items[slot] = fallbackItem
 129         }
 130     }
 131
 132     @JvmOverloads
 133     fun decreaseCurrentItemAmount(count: Int = 1) {
 134         decreaseItemAmount(activeSlot, count)
 135     }
 136 }