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

   1 package ru.deadsoftware.cavedroid.game.render
   2
   3 import com.badlogic.gdx.graphics.g2d.Sprite
   4 import com.badlogic.gdx.graphics.g2d.SpriteBatch
   5 import com.badlogic.gdx.graphics.glutils.ShapeRenderer
   6 import com.badlogic.gdx.math.MathUtils
   7 import com.badlogic.gdx.math.Rectangle
   8 import ru.deadsoftware.cavedroid.game.mobs.MobsController
   9 import ru.deadsoftware.cavedroid.game.model.block.Block
  10 import ru.deadsoftware.cavedroid.game.world.GameWorld
  11 import ru.deadsoftware.cavedroid.misc.Assets
  12 import ru.deadsoftware.cavedroid.misc.utils.px
  13
  14 abstract class BlocksRenderer(
  15     protected val gameWorld: GameWorld,
  16     protected val mobsController: MobsController,
  17 ) : IGameRenderer {
  18
  19     protected abstract val background: Boolean
  20
  21     private val Block.canSeeThrough
  22         get() = isNone() || params.isTransparent
  23
  24     private fun blockDamageSprite(index: Int): Sprite? {
  25         if (index !in 0..< MAX_BLOCK_DAMAGE_INDEX) {
  26             return null
  27         }
  28         return Assets.blockDamageSprites[index]
  29     }
  30
  31     protected fun drawBlockDamage(spriteBatch: SpriteBatch, viewport: Rectangle) {
  32         val player = mobsController.player
  33         val blockDamage = player.blockDamage.takeIf { it > 0f } ?: return
  34         val cursorX = player.cursorX
  35         val cursorY = player.cursorY
  36
  37         val block = if (background) {
  38             gameWorld.getBackMap(cursorX, cursorY)
  39         } else {
  40             gameWorld.getForeMap(cursorX, cursorY)
  41         }
  42
  43         val index = (MAX_BLOCK_DAMAGE_INDEX.toFloat() * (blockDamage.toFloat() / block.params.hitPoints.toFloat()))
  44             .let(MathUtils::floor)
  45         val sprite = blockDamageSprite(index) ?: return
  46
  47         if (gameWorld.hasForeAt(cursorX, cursorY) != background) {
  48             sprite.setBounds(
  49                 /* x = */ cursorX.px - viewport.x + block.params.spriteMargins.left,
  50                 /* y = */ cursorY.px - viewport.y + block.params.spriteMargins.top,
  51                 /* width = */ block.spriteWidth,
  52                 /* height = */ block.spriteHeight
  53             )
  54             sprite.draw(spriteBatch)
  55         }
  56     }
  57
  58     protected fun shadeBackMap(
  59         shapeRenderer: ShapeRenderer,
  60         viewport: Rectangle,
  61         x: Int,
  62         y: Int
  63     ) {
  64         val foregroundBlock = gameWorld.getForeMap(x, y)
  65         val backgroundBlock = gameWorld.getBackMap(x, y)
  66
  67         if (foregroundBlock.canSeeThrough && !backgroundBlock.isNone()) {
  68             val drawX = x.px - viewport.x
  69             val drawY = y.px - viewport.y
  70             val marginLeft = backgroundBlock.params.spriteMargins.left
  71             val marginTop = backgroundBlock.params.spriteMargins.top
  72
  73             shapeRenderer.rect(
  74                 /* x = */ drawX + marginLeft,
  75                 /* y = */ drawY + marginTop,
  76                 /* width = */ backgroundBlock.width,
  77                 /* height = */ backgroundBlock.height
  78             )
  79         }
  80     }
  81
  82     protected fun drawBackMap(spriteBatch: SpriteBatch, viewport: Rectangle, x: Int, y: Int) {
  83         val foregroundBlock = gameWorld.getForeMap(x, y)
  84         val backgroundBlock = gameWorld.getBackMap(x, y)
  85
  86         if (foregroundBlock.canSeeThrough && !backgroundBlock.isNone()) {
  87             val drawX = x.px - viewport.x
  88             val drawY = y.px - viewport.y
  89             if (backgroundBlock is Block.Furnace) {
  90                 backgroundBlock.draw(spriteBatch, drawX, drawY, gameWorld.getBackgroundFurnace(x, y)?.isActive ?: false)
  91             } else {
  92                 backgroundBlock.draw(spriteBatch, drawX, drawY)
  93             }
  94         }
  95     }
  96
  97     protected fun drawForeMap(spriteBatch: SpriteBatch, viewport: Rectangle, x: Int, y: Int) {
  98         val foregroundBlock = gameWorld.getForeMap(x, y)
  99
 100         if (!foregroundBlock.isNone() && foregroundBlock.params.isBackground == background) {
 101             val drawX = x.px - viewport.x
 102             val drawY = y.px - viewport.y
 103
 104             if (foregroundBlock is Block.Furnace) {
 105                 foregroundBlock.draw(spriteBatch, drawX, drawY, gameWorld.getForegroundFurnace(x, y)?.isActive ?: false)
 106             } else {
 107                 foregroundBlock.draw(spriteBatch, drawX, drawY)
 108             }
 109         }
 110     }
 111
 112     companion object {
 113         private const val MAX_BLOCK_DAMAGE_INDEX = 10
 114     }
 115
 116 }