core/src/ru/deadsoftware/cavedroid/game/render/HudRenderer.kt

   1 package ru.deadsoftware.cavedroid.game.render
   2
   3 import com.badlogic.gdx.graphics.g2d.SpriteBatch
   4 import com.badlogic.gdx.graphics.glutils.ShapeRenderer
   5 import com.badlogic.gdx.math.Rectangle
   6 import ru.deadsoftware.cavedroid.game.GameInput
   7 import ru.deadsoftware.cavedroid.game.GameScope
   8 import ru.deadsoftware.cavedroid.game.mobs.MobsController
   9 import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
  10 import ru.deadsoftware.cavedroid.game.world.GameWorld
  11 import ru.deadsoftware.cavedroid.misc.Assets
  12 import ru.deadsoftware.cavedroid.misc.ControlMode
  13 import ru.deadsoftware.cavedroid.misc.utils.px
  14 import javax.inject.Inject
  15
  16 @GameScope
  17 class HudRenderer @Inject constructor(
  18     private val gameInput: GameInput,
  19     private val gameWorld: GameWorld,
  20     private val mobsController: MobsController,
  21 ) : IGameRenderer {
  22
  23     override val renderLayer = RENDER_LAYER
  24
  25     private val cursorTexture get() = requireNotNull(Assets.textureRegions[CURSOR_KEY])
  26     private val hotbarTexture get() = requireNotNull(Assets.textureRegions[HOTBAR_KEY])
  27     private val hotbarSelectorTexture get() = requireNotNull(Assets.textureRegions[HOTBAR_SELECTOR_KEY])
  28     private val wholeHeartTexture get() = requireNotNull(Assets.textureRegions[WHOLE_HEART_KEY])
  29     private val halfHeartTexture get() = requireNotNull(Assets.textureRegions[HALF_HEART_KEY])
  30
  31     private fun drawCursor(spriteBatch: SpriteBatch, viewport: Rectangle) {
  32         if (gameWorld.hasForeAt(gameInput.curX, gameInput.curY) ||
  33             gameWorld.hasBackAt(gameInput.curX, gameInput.curY) ||
  34             gameInput.controlMode == ControlMode.CURSOR
  35         ) {
  36             spriteBatch.draw(cursorTexture, gameInput.curX.px - viewport.x, gameInput.curY.px - viewport.y)
  37         }
  38     }
  39
  40     private fun drawHealth(spriteBatch: SpriteBatch, x: Float, y: Float) {
  41         val player = mobsController.player
  42
  43         if (player.gameMode == 1) {
  44             return
  45         }
  46
  47         val wholeHeart = wholeHeartTexture
  48         val wholeHearts = player.health / 2
  49
  50         for (i in 0..<wholeHearts) {
  51             spriteBatch.draw(wholeHeart, x + i * wholeHeart.regionWidth, y)
  52         }
  53
  54         if (player.health % 2 == 1) {
  55             spriteBatch.draw(halfHeartTexture, x + wholeHearts * wholeHeart.regionWidth, y)
  56         }
  57     }
  58
  59     private fun drawHotbarItems(spriteBatch: SpriteBatch, hotbarX: Float) {
  60         mobsController.player.inventory.asSequence()
  61             .map(InventoryItem::item)
  62             .forEachIndexed { index, item ->
  63                 if (item.isNone()) {
  64                     return@forEachIndexed
  65                 }
  66
  67                 spriteBatch.draw(
  68                     /* region = */ item.sprite,
  69                     /* x = */ hotbarX + HotbarConfig.horizontalMargin
  70                             + index * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
  71                     /* y = */ HotbarConfig.verticalMargin,
  72                 )
  73             }
  74     }
  75
  76     private fun drawHotbarSelector(spriteBatch: SpriteBatch, hotbarX: Float) {
  77         spriteBatch.draw(
  78             /* region = */ hotbarSelectorTexture,
  79             /* x = */ hotbarX - HotbarSelectorConfig.horizontalPadding
  80                     + mobsController.player.slot * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
  81             /* y = */ -HotbarSelectorConfig.verticalPadding
  82         )
  83     }
  84
  85     private fun drawHotbar(spriteBatch: SpriteBatch, viewport: Rectangle) {
  86         val hotbar = hotbarTexture
  87         val hotbarX = viewport.width / 2 - hotbar.regionWidth / 2
  88
  89         spriteBatch.draw(hotbar, hotbarX, 0f)
  90         drawHealth(spriteBatch, hotbarX, hotbarTexture.regionHeight.toFloat())
  91         drawHotbarItems(spriteBatch, hotbarX)
  92         drawHotbarSelector(spriteBatch, hotbarX)
  93     }
  94
  95     override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
  96         drawCursor(spriteBatch, viewport)
  97         drawHotbar(spriteBatch, viewport)
  98     }
  99
 100     companion object {
 101         private const val RENDER_LAYER = 100500
 102
 103         private const val CURSOR_KEY = "cursor"
 104         private const val HOTBAR_KEY = "hotbar"
 105         private const val HOTBAR_SELECTOR_KEY = "hotbar_selector"
 106         private const val WHOLE_HEART_KEY = "heart_whole"
 107         private const val HALF_HEART_KEY = "heart_half"
 108
 109         private data object HotbarConfig {
 110             const val horizontalMargin = 3f
 111             const val verticalMargin = 3f
 112             const val itemSeparatorWidth = 4f
 113             const val itemSlotSpace = 16f
 114         }
 115
 116         private data object HotbarSelectorConfig {
 117             const val horizontalPadding = 1f
 118             const val verticalPadding = 1f
 119         }
 120     }
 121 }