release-*/
keystore.properties
-*/build/
+**/build/
+**/_build/
"h": 26
}
},
- "pp/allitems": {
+ "textures/allitems": {
"creative": {
"w": 176,
"h": 136
"h": 15
}
},
- "pp/inventory": {
+ "textures/inventory": {
"survival": {
"w": 176,
"h": 166
}
},
- "pp/crafting_table": {
+ "textures/crafting_table": {
"crafting_table": {
"w": 176,
"h": 166
}
},
- "pp/furnace": {
+ "textures/furnace": {
"furnace": {
"w": 176,
"h": 166
"h": 14
}
},
- "pp/chest": {
+ "textures/chest": {
"chest": {
"w": 176,
"h": 168
}
},
- "pp/buttons": {
+ "textures/buttons": {
"button_0": {
"w": 200,
"h": 20
"h": 20
}
},
- "pp/gui": {
+ "textures/gui": {
"hotbar": {
"y": 16,
"w": 182,
"h": 16
}
},
- "pp/shade": {},
+ "shade": {},
"gamelogo": {},
- "pp/background": {},
- "pp/health":{
+ "textures/background": {},
+ "textures/health":{
"heart_whole": {
"w": 9
},
"x": 18,
"w": 9
}
- }
+ },
+ "joy_stick": {},
+ "joy_background": {}
}
\ No newline at end of file
+import org.gradle.kotlin.dsl.version
+
object Dependencies {
object LibGDX {
object Kotlin {
const val gradlePlugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:${Versions.kotlin}"
+ const val kspPlugin = "com.google.devtools.ksp:${Versions.ksp}"
const val bom = "org.jetbrains.kotlin:kotlin-bom:${Versions.kotlin}"
const val stdlib = "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}"
--- /dev/null
+import org.gradle.api.artifacts.dsl.DependencyHandler
+import org.gradle.kotlin.dsl.project
+
+private fun DependencyHandler.implementation(dependency: String) =
+ add("implementation", dependency)
+
+private fun DependencyHandler.ksp(dependency: String) =
+ add("ksp", dependency)
+
+fun DependencyHandler.useModule(moduleName: String) {
+ add("implementation", project(moduleName))
+}
+
+fun DependencyHandler.useBaseModule() {
+ useModule(":core:base")
+}
+
+fun DependencyHandler.useAutomultibind() {
+ implementation(Dependencies.Automultibind.annotations)
+ ksp(Dependencies.Automultibind.ksp)
+}
+
+fun DependencyHandler.useLibgdx() {
+ implementation(Dependencies.LibGDX.gdx)
+}
+
+fun DependencyHandler.useDagger() {
+ implementation(Dependencies.Dagger.dagger)
+ ksp(Dependencies.Dagger.compiler)
+}
+
+fun DependencyHandler.useKotlinxSerializationJson() {
+ implementation(Dependencies.Kotlin.Serialization.json)
+}
+
+fun DependencyHandler.useKotlinxSerializationProtobuf() {
+ implementation(Dependencies.Kotlin.Serialization.protobuf)
+}
--- /dev/null
+import org.gradle.kotlin.dsl.PluginDependenciesSpecScope
+import org.gradle.kotlin.dsl.version
+
+val PluginDependenciesSpecScope.kotlin
+ get() = id("kotlin")
+val PluginDependenciesSpecScope.ksp
+ get() = id("com.google.devtools.ksp") version Versions.ksp
+val PluginDependenciesSpecScope.kotlinxSerialization
+ get() = id("org.jetbrains.kotlin.plugin.serialization") version Versions.kotlin
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+}
--- /dev/null
+package ru.fredboy.cavedroid.utils
+
+import com.badlogic.gdx.math.MathUtils
+
+const val BLOCK_SIZE_PX = 16f
+
+/**
+ * Converts this value in BLOCKS into pixels
+ */
+val Float.px get() = this * BLOCK_SIZE_PX
+
+/**
+ * Converts this value in BLOCKS into pixels
+ */
+val Int.px get() = this * BLOCK_SIZE_PX
+
+/**
+ * Converts this value in PIXELS into blocks
+ */
+val Float.bl get() = MathUtils.floor(this / BLOCK_SIZE_PX)
+
+/**
+ * Converts this value in PIXELS into blocks
+ */
+val Int.bl get() = MathUtils.floor(this / BLOCK_SIZE_PX)
java.sourceCompatibility = ApplicationInfo.sourceCompatibility
java.targetCompatibility = ApplicationInfo.sourceCompatibility
+sourceSets {
+ buildDir = file("_build")
+}
+
dependencies {
- implementation(Dependencies.Automultibind.annotations)
- ksp(Dependencies.Automultibind.ksp)
+ useAutomultibind()
+ useDagger()
+ useLibgdx()
+ useKotlinxSerializationJson()
+ useKotlinxSerializationProtobuf()
- implementation(Dependencies.LibGDX.gdx)
- implementation(Dependencies.Dagger.dagger)
+ useBaseModule()
- implementation(Dependencies.jetbrainsAnnotations)
- implementation(Dependencies.Kotlin.stdlib)
- implementation(Dependencies.Kotlin.Serialization.json)
- implementation(Dependencies.Kotlin.Serialization.protobuf)
+ // data
+ useModule(":core:data:assets")
- ksp(Dependencies.Dagger.compiler)
+ //domain
+ useModule(":core:domain:assets")
+
+ implementation(Dependencies.jetbrainsAnnotations)
}
\ No newline at end of file
--- /dev/null
+plugins {
+ kotlin
+ ksp
+ kotlinxSerialization
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useBaseModule()
+ useModule(":core:domain:assets")
+ useLibgdx()
+ useKotlinxSerializationJson()
+ useDagger()
+}
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.data.assets.internal.*
+import ru.fredboy.cavedroid.data.assets.internal.BlockDamageAssetsRepositoryImpl
+import ru.fredboy.cavedroid.data.assets.internal.FontAssetsRepositoryImpl
+import ru.fredboy.cavedroid.data.assets.internal.MobAssetsRepositoryImpl
+import ru.fredboy.cavedroid.data.assets.internal.TextureRegionsAssetsRepositoryImpl
+import ru.fredboy.cavedroid.domain.assets.repository.*
+
+@Module
+abstract class DataAssetsModule {
+
+ @Binds
+ internal abstract fun bindBlockDamageAssetsRepository(
+ impl: BlockDamageAssetsRepositoryImpl
+ ): BlockDamageAssetsRepository
+
+ @Binds
+ internal abstract fun bindMobAssetsRepository(
+ impl: MobAssetsRepositoryImpl
+ ): MobAssetsRepository
+
+ @Binds
+ internal abstract fun bindTextureRegionsAssetsRepository(
+ impl: TextureRegionsAssetsRepositoryImpl
+ ): TextureRegionsAssetsRepository
+
+ @Binds
+ internal abstract fun bindFontAssetsRepository(
+ impl: FontAssetsRepositoryImpl
+ ): FontAssetsRepository
+
+ @Binds
+ internal abstract fun bindBlockAssetsRepository(
+ impl: BlockAssetsRepositoryImpl
+ ): BlockAssetsRepository
+
+ @Binds
+ internal abstract fun bindItemsAssetsRepository(
+ impl: ItemsAssetsRepositoryImpl
+ ): ItemsAssetsRepository
+
+ @Binds
+ internal abstract fun bindTouchButtonsAssetsRepository(
+ impl: TouchButtonsRepositoryImpl
+ ): TouchButtonsAssetsRepository
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import com.badlogic.gdx.graphics.Texture
+import ru.fredboy.cavedroid.domain.assets.repository.BlockAssetsRepository
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class BlockAssetsRepositoryImpl @Inject constructor() : BlockAssetsRepository() {
+
+ private val blockTexturesCache = HashMap<String, Texture>()
+
+ override fun getBlockTexture(textureName: String): Texture {
+ return resolveTexture(textureName, BLOCKS_TEXTURES_PATH, blockTexturesCache)
+ }
+
+ override fun initialize() {
+ // no-op
+ }
+
+ override fun dispose() {
+ super.dispose()
+ blockTexturesCache.clear()
+ }
+
+ companion object {
+ private const val BLOCKS_TEXTURES_PATH = "textures/textures/blocks"
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import com.badlogic.gdx.graphics.g2d.Sprite
+import ru.fredboy.cavedroid.domain.assets.repository.BlockDamageAssetsRepository
+import ru.fredboy.cavedroid.utils.BLOCK_SIZE_PX
+import ru.fredboy.cavedroid.utils.bl
+import ru.fredboy.cavedroid.utils.px
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class BlockDamageAssetsRepositoryImpl @Inject constructor() : BlockDamageAssetsRepository() {
+
+ private var blockDamageSprites: Array<Sprite>? = null
+
+ override val damageStages: Int
+ get() = requireNotNull(blockDamageSprites).size
+
+ private fun loadBlockDamage() {
+ val blockDamageTexture = loadTexture(BLOCK_DAMAGE_SHEET_PATH)
+ val size = blockDamageTexture.width.bl
+ val blockSize = BLOCK_SIZE_PX.toInt()
+
+ blockDamageSprites = Array(size) { index ->
+ flippedSprite(
+ texture = blockDamageTexture,
+ x = index.px.toInt(),
+ y = 0,
+ width = blockSize,
+ height = blockSize
+ )
+ }
+ }
+
+ override fun getBlockDamageSprite(stage: Int): Sprite {
+ return requireNotNull(blockDamageSprites)[stage]
+ }
+
+ override fun initialize() {
+ loadBlockDamage()
+ }
+
+ override fun dispose() {
+ super.dispose()
+ blockDamageSprites = null
+ }
+
+ companion object {
+ private const val BLOCK_DAMAGE_SHEET_PATH = "textures/break.png"
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+import com.badlogic.gdx.graphics.g2d.GlyphLayout
+import ru.fredboy.cavedroid.domain.assets.repository.FontAssetsRepository
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class FontAssetsRepositoryImpl @Inject constructor() : FontAssetsRepository() {
+
+ private val glyphLayout = GlyphLayout()
+
+ private var font: BitmapFont? = null
+
+ override fun getStringWidth(string: String): Float {
+ glyphLayout.setText(font, string)
+ return glyphLayout.width
+ }
+
+ override fun getStringHeight(string: String): Float {
+ glyphLayout.setText(font, string)
+ return glyphLayout.height
+ }
+
+ override fun getFont(): BitmapFont {
+ return requireNotNull(font)
+ }
+
+ override fun initialize() {
+ font = BitmapFont(Gdx.files.internal(FONT_FILE_PATH), true)
+ .apply {
+ data.setScale(.375f)
+ setUseIntegerPositions(false)
+ }
+ }
+
+ override fun dispose() {
+ super.dispose()
+ font?.dispose()
+ }
+
+ companion object {
+ private const val FONT_FILE_PATH = "font.fnt"
+ private const val FONT_SCALE = .375f
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import com.badlogic.gdx.graphics.Texture
+import ru.fredboy.cavedroid.domain.assets.repository.ItemsAssetsRepository
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class ItemsAssetsRepositoryImpl @Inject constructor() : ItemsAssetsRepository() {
+
+ private val itemTexturesCache = HashMap<String, Texture>()
+
+ override fun getItemTexture(textureName: String): Texture {
+ return resolveTexture(textureName, ITEMS_TEXTURES_PATH, itemTexturesCache)
+ }
+
+ override fun initialize() {
+ // no-op
+ }
+
+ override fun dispose() {
+ super.dispose()
+ itemTexturesCache.clear()
+ }
+
+ companion object {
+ private const val ITEMS_TEXTURES_PATH = "textures/textures/items"
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class MobAssetsRepositoryImpl @Inject constructor(): MobAssetsRepository() {
+
+ private var playerSprite: MobSprite.Player? = null
+
+ private var pigSprite: MobSprite.Pig? = null
+
+ private fun loadPlayerSprite() {
+ val (headTexture, bodyTexture, handTexture, legTexture) = List(4) { index ->
+ loadTexture("$PLAYER_SPRITES_PATH/$index.png")
+ }
+
+ playerSprite = MobSprite.Player(
+ head = flippedSprite(headTexture),
+ hand = flippedSprite(handTexture),
+ body = flippedSprite(bodyTexture),
+ leg = flippedSprite(legTexture),
+ )
+ }
+
+ private fun loadPigSprite() {
+ val (bodyTexture, legTexture) = List(2) { index ->
+ loadTexture("$PIG_SPRITES_PATH/$index.png")
+ }
+
+ pigSprite = MobSprite.Pig(
+ headAndBody = flippedSprite(bodyTexture),
+ leg = flippedSprite(legTexture),
+ )
+ }
+
+ override fun getPlayerSprites(): MobSprite.Player {
+ return requireNotNull(playerSprite)
+ }
+
+ override fun getPigSprites(): MobSprite.Pig {
+ return requireNotNull(pigSprite)
+ }
+
+ override fun initialize() {
+ loadPlayerSprite()
+ loadPigSprite()
+ }
+
+ override fun dispose() {
+ super.dispose()
+ playerSprite = null
+ pigSprite = null
+ }
+
+ companion object {
+ private const val PLAYER_SPRITES_PATH = "textures/mobs/char"
+ private const val PIG_SPRITES_PATH = "textures/mobs/pig"
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.g2d.TextureRegion
+import kotlinx.serialization.json.Json
+import ru.fredboy.cavedroid.data.assets.model.region.TextureRegionsDto
+import ru.fredboy.cavedroid.domain.assets.repository.TextureRegionsAssetsRepository
+import java.io.File
+import java.util.*
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class TextureRegionsAssetsRepositoryImpl @Inject constructor() : TextureRegionsAssetsRepository() {
+
+ private var textureRegions: HashMap<String, TextureRegion>? = null
+
+ private fun loadTextureRegions() {
+ val file = Gdx.files.internal(JSON_TEXTURE_REGIONS)
+ val dto = JsonFormat.decodeFromString<TextureRegionsDto>(file.readString())
+
+ val regions = HashMap<String, TextureRegion>()
+
+ dto.forEach { (fileName, fileData) ->
+ val texture = loadTexture("$fileName.png")
+
+ if (fileData.isEmpty()) {
+ regions[fileName.split(File.separator).last()] = flippedRegion(
+ texture = texture,
+ x = 0,
+ y = 0,
+ width = texture.width,
+ height = texture.height
+ )
+ } else {
+ fileData.forEach { (regionName, regionData) ->
+ regions[regionName.split(File.separator).last()] = flippedRegion(
+ texture = texture,
+ x = regionData.x,
+ y = regionData.y,
+ width = regionData.width ?: texture.width,
+ height = regionData.height ?: texture.height
+ )
+ }
+ }
+ }
+
+ textureRegions = regions
+ }
+
+ override fun initialize() {
+ loadTextureRegions()
+ }
+
+ override fun getTextureRegionByName(name: String): TextureRegion? {
+ return requireNotNull(textureRegions)[name]
+ }
+
+ override fun dispose() {
+ super.dispose()
+ textureRegions = null
+ }
+
+ companion object {
+ private val JsonFormat = Json { ignoreUnknownKeys = true }
+
+ private const val JSON_TEXTURE_REGIONS = "json/texture_regions.json"
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.internal
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.Input
+import com.badlogic.gdx.math.Rectangle
+import kotlinx.serialization.json.Json
+import ru.fredboy.cavedroid.data.assets.model.button.TouchButtonsDto
+import ru.fredboy.cavedroid.domain.assets.model.TouchButton
+import ru.fredboy.cavedroid.domain.assets.repository.TouchButtonsAssetsRepository
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class TouchButtonsRepositoryImpl @Inject constructor() : TouchButtonsAssetsRepository() {
+
+ private val guiMap = HashMap<String, TouchButton>()
+
+ override fun getTouchButtons(): Map<String, TouchButton> {
+ return guiMap
+ }
+
+ private fun getMouseKey(name: String): Int {
+ return when (name) {
+ "Left" -> Input.Buttons.LEFT
+ "Right" -> Input.Buttons.RIGHT
+ "Middle" -> Input.Buttons.MIDDLE
+ "Back" -> Input.Buttons.BACK
+ "Forward" -> Input.Buttons.FORWARD
+ else -> -1
+ }
+ }
+
+ private fun loadTouchButtons() {
+ val file = Gdx.files.internal(JSON_TOUCH_BUTTONS)
+ val buttons = JsonFormat.decodeFromString<TouchButtonsDto>(file.readString())
+
+ buttons.forEach { (name, data) ->
+ guiMap[name] = TouchButton(
+ rectangle = Rectangle(data.x, data.y, data.width, data.height),
+ code = if (data.isMouse) getMouseKey(name) else Input.Keys.valueOf(name),
+ isMouse = data.isMouse,
+ )
+ }
+ }
+
+ override fun initialize() {
+ loadTouchButtons()
+ }
+
+ override fun dispose() {
+ super.dispose()
+ guiMap.clear()
+ }
+
+ companion object {
+ private val JsonFormat = Json { ignoreUnknownKeys = true }
+
+ private const val JSON_TOUCH_BUTTONS = "json/touch_buttons.json"
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.model.button
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class TouchButtonDto(
+ @SerialName("x") val x: Float,
+ @SerialName("y") val y: Float,
+ @SerialName("w") val width: Float,
+ @SerialName("h") val height: Float,
+ @SerialName("mouse") val isMouse: Boolean = false,
+ @SerialName("key") val key: String,
+)
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.model.button
+
+typealias TouchButtonsDto = Map<String, TouchButtonDto>
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.model.region
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class TextureRegionDto(
+ @SerialName("x") val x: Int = 0,
+ @SerialName("y") val y: Int = 0,
+ @SerialName("w") val width: Int? = null,
+ @SerialName("h") val height: Int? = null,
+)
--- /dev/null
+package ru.fredboy.cavedroid.data.assets.model.region
+
+internal typealias TextureRegionsDto = Map<String, Map<String, TextureRegionDto>>
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useBaseModule()
+ useLibgdx()
+ useDagger()
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets
+
+import com.badlogic.gdx.graphics.Texture
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+import com.badlogic.gdx.graphics.g2d.Sprite
+import com.badlogic.gdx.graphics.g2d.TextureRegion
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import ru.fredboy.cavedroid.domain.assets.model.TouchButton
+import ru.fredboy.cavedroid.domain.assets.repository.*
+import javax.inject.Inject
+
+@Reusable
+class GameAssetsHolder @Inject constructor(
+ private val blockAssetsRepository: BlockAssetsRepository,
+ private val blockDamageAssetsRepository: BlockDamageAssetsRepository,
+ private val fontAssetsRepository: FontAssetsRepository,
+ private val itemsAssetsRepository: ItemsAssetsRepository,
+ private val mobAssetsRepository: MobAssetsRepository,
+ private val textureRegionsAssetsRepository: TextureRegionsAssetsRepository,
+ private val touchButtonsAssetsRepository: TouchButtonsAssetsRepository
+) {
+
+ private val repositories = sequenceOf(
+ blockAssetsRepository,
+ blockDamageAssetsRepository,
+ fontAssetsRepository,
+ itemsAssetsRepository,
+ mobAssetsRepository,
+ textureRegionsAssetsRepository,
+ touchButtonsAssetsRepository
+ )
+
+ fun initializeRepository() {
+ repositories.forEach(AssetsRepository::initialize)
+ }
+
+ fun dispose() {
+ repositories.forEach(AssetsRepository::dispose)
+ }
+
+ fun getBlockTexture(textureName: String): Texture {
+ return blockAssetsRepository.getBlockTexture(textureName)
+ }
+
+ fun getItemTexture(textureName: String): Texture {
+ return itemsAssetsRepository.getItemTexture(textureName)
+ }
+
+ fun getBlockDamageFrameCount(): Int {
+ return blockDamageAssetsRepository.damageStages
+ }
+
+ fun getBlockDamageSprite(stage: Int): Sprite {
+ return blockDamageAssetsRepository.getBlockDamageSprite(stage)
+ }
+
+ fun getStringWidth(string: String): Float {
+ return fontAssetsRepository.getStringWidth(string)
+ }
+
+ fun getStringHeight(string: String): Float {
+ return fontAssetsRepository.getStringHeight(string)
+ }
+
+ fun getFont(): BitmapFont {
+ return fontAssetsRepository.getFont()
+ }
+
+ fun getPlayerSprites(): MobSprite.Player {
+ return mobAssetsRepository.getPlayerSprites()
+ }
+
+ fun getPigSprites(): MobSprite.Pig {
+ return mobAssetsRepository.getPigSprites()
+ }
+
+ fun getTouchButtons(): Map<String, TouchButton> {
+ return touchButtonsAssetsRepository.getTouchButtons()
+ }
+
+ fun getTextureRegionByName(name: String): TextureRegion? {
+ return textureRegionsAssetsRepository.getTextureRegionByName(name)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.model
+
+import com.badlogic.gdx.graphics.g2d.Sprite
+
+sealed interface MobSprite {
+
+ data class Player(
+ val head: Sprite,
+ val hand: Sprite,
+ val body: Sprite,
+ val leg: Sprite,
+ ) : MobSprite {
+ fun getBodyRelativeX() = 2
+
+ fun getBodyRelativeY() = 8
+
+ fun getLegsRelativeY() = 20
+ }
+
+ data class Pig(
+ val headAndBody: Sprite,
+ val leg: Sprite
+ ) : MobSprite {
+
+ fun getLeftLegRelativeX(directionIndex: Int) = 9 - directionIndex * 9
+
+ fun getRightLegRelativeX(directionIndex: Int) = 21 - (9 * directionIndex)
+
+ fun getLegsRelativeY() = 12
+
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.model
+
+import com.badlogic.gdx.math.Rectangle
+
+data class TouchButton(
+ val rectangle: Rectangle,
+ val code: Int,
+ val isMouse: Boolean
+)
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.Texture
+import com.badlogic.gdx.graphics.g2d.Sprite
+import com.badlogic.gdx.graphics.g2d.TextureRegion
+import com.badlogic.gdx.utils.Disposable
+import java.util.*
+
+abstract class AssetsRepository : Disposable {
+
+ protected val loadedTextures = LinkedList<Texture>()
+
+ protected fun loadTexture(path: String): Texture {
+ return Texture(Gdx.files.internal(path)).also { texture ->
+ loadedTextures.add(texture)
+ }
+ }
+
+ protected fun flippedRegion(
+ texture: Texture,
+ x: Int,
+ y: Int,
+ width: Int,
+ height: Int
+ ): TextureRegion {
+ return TextureRegion(texture, x, y + height, width, -height)
+ }
+
+ protected fun flippedSprite(
+ texture: Texture
+ ): Sprite {
+ return Sprite(texture).apply { flip(false, true) }
+ }
+
+ protected fun flippedSprite(
+ texture: Texture,
+ x: Int,
+ y: Int,
+ width: Int,
+ height: Int
+ ): Sprite {
+ return Sprite(flippedRegion(texture, x, y, width, height))
+ }
+
+ protected fun resolveTexture(
+ textureName: String,
+ lookupPath: String,
+ cache: MutableMap<String, Texture>
+ ): Texture {
+ val cached = cache[textureName]
+
+ if (cached != null) {
+ return cached
+ }
+
+ val texture = loadTexture("$lookupPath/$textureName.png")
+ cache[textureName] = texture
+
+ return texture
+ }
+
+ override fun dispose() {
+ loadedTextures.forEach(Texture::dispose)
+ loadedTextures.clear()
+ }
+
+ abstract fun initialize()
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import com.badlogic.gdx.graphics.Texture
+
+abstract class BlockAssetsRepository : AssetsRepository() {
+
+ abstract fun getBlockTexture(textureName: String): Texture
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import com.badlogic.gdx.graphics.g2d.Sprite
+
+abstract class BlockDamageAssetsRepository : AssetsRepository() {
+
+ abstract val damageStages: Int
+
+ abstract fun getBlockDamageSprite(stage: Int): Sprite
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+
+abstract class FontAssetsRepository : AssetsRepository() {
+
+ abstract fun getStringWidth(string: String): Float
+
+ abstract fun getStringHeight(string: String): Float
+
+ abstract fun getFont(): BitmapFont
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import com.badlogic.gdx.graphics.Texture
+
+abstract class ItemsAssetsRepository : AssetsRepository() {
+
+ abstract fun getItemTexture(textureName: String): Texture
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+
+abstract class MobAssetsRepository : AssetsRepository() {
+
+ abstract fun getPlayerSprites(): MobSprite.Player
+
+ abstract fun getPigSprites(): MobSprite.Pig
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import com.badlogic.gdx.graphics.g2d.TextureRegion
+
+abstract class TextureRegionsAssetsRepository : AssetsRepository() {
+
+ abstract fun getTextureRegionByName(name: String): TextureRegion?
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.repository
+
+import ru.fredboy.cavedroid.domain.assets.model.TouchButton
+
+abstract class TouchButtonsAssetsRepository : AssetsRepository() {
+
+ abstract fun getTouchButtons(): Map<String, TouchButton>
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class DisposeAssetsUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder
+) {
+
+ operator fun invoke() {
+ gameAssetsHolder.dispose()
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetBlockDamageFrameCountUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(): Int {
+ return gameAssetsHolder.getBlockDamageFrameCount()
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import com.badlogic.gdx.graphics.g2d.Sprite
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetBlockDamageSpriteUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun get(stage: Int): Sprite {
+ return gameAssetsHolder.getBlockDamageSprite(stage)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import com.badlogic.gdx.graphics.Texture
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetBlockTextureUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder
+) {
+
+ operator fun get(name: String): Texture {
+ return gameAssetsHolder.getBlockTexture(name)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetFontUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(): BitmapFont {
+ return gameAssetsHolder.getFont()
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import com.badlogic.gdx.graphics.Texture
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetItemTextureUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder
+) {
+
+ operator fun get(name: String): Texture {
+ return gameAssetsHolder.getItemTexture(name)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import javax.inject.Inject
+
+@Reusable
+class GetPigSpritesUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(): MobSprite.Pig {
+ return gameAssetsHolder.getPigSprites()
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import javax.inject.Inject
+
+@Reusable
+class GetPlayerSpritesUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(): MobSprite.Player {
+ return gameAssetsHolder.getPlayerSprites()
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetStringHeightUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(string: String): Float {
+ return gameAssetsHolder.getStringHeight(string)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetStringWidthUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(string: String): Float {
+ return gameAssetsHolder.getStringWidth(string)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import com.badlogic.gdx.graphics.g2d.TextureRegion
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class GetTextureRegionByNameUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun get(name: String): TextureRegion? {
+ return gameAssetsHolder.getTextureRegionByName(name)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import ru.fredboy.cavedroid.domain.assets.model.TouchButton
+import javax.inject.Inject
+
+@Reusable
+class GetTouchButtonsUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke(): Map<String, TouchButton> {
+ return gameAssetsHolder.getTouchButtons()
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.assets.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import javax.inject.Inject
+
+@Reusable
+class InitializeAssetsUseCase @Inject constructor(
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ operator fun invoke() {
+ gameAssetsHolder.initializeRepository()
+ }
+
+}
\ No newline at end of file
import ru.deadsoftware.cavedroid.generated.module.*;
@GameScope
-@Component(dependencies = MainComponent.class,
+@Component(dependencies = {
+ MainComponent.class
+ },
modules = {GameModule.class,
UseItemActionsModule.class,
UpdateBlockActionsModule.class,
import ru.deadsoftware.cavedroid.game.save.GameSaveLoader;
import ru.deadsoftware.cavedroid.game.ui.TooltipManager;
import ru.deadsoftware.cavedroid.game.world.GameWorld;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPlayerSpritesUseCase;
@Module
public class GameModule {
public static boolean loaded = false;
- private static void load(MainConfig mainConfig, GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
+ private static void load(MainConfig mainConfig,
+ GameItemsHolder gameItemsHolder,
+ TooltipManager tooltipManager,
+ GetPlayerSpritesUseCase getPlayerSpritesUseCase,
+ GetPigSpritesUseCase getPigSpritesUseCase) {
if (loaded) {
return;
}
- data = GameSaveLoader.INSTANCE.load(mainConfig, gameItemsHolder, tooltipManager);
+
+ data = GameSaveLoader.INSTANCE.load(mainConfig,
+ gameItemsHolder,
+ tooltipManager,
+ getPlayerSpritesUseCase,
+ getPigSpritesUseCase);
+
loaded = true;
}
@GameScope
public static DropController provideDropController(MainConfig mainConfig,
GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager) {
- load(mainConfig, gameItemsHolder, tooltipManager);
+ TooltipManager tooltipManager,
+ GetPlayerSpritesUseCase getPlayerSpritesUseCase,
+ GetPigSpritesUseCase getPigSpritesUseCase) {
+ load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
DropController controller = data != null ? data.retrieveDropController() : new DropController();
makeDataNullIfEmpty();
controller.initDrops(gameItemsHolder);
public static ContainerController provideFurnaceController(MainConfig mainConfig,
DropController dropController,
GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager) {
- load(mainConfig, gameItemsHolder, tooltipManager);
+ TooltipManager tooltipManager,
+ GetPlayerSpritesUseCase getPlayerSpritesUseCase,
+ GetPigSpritesUseCase getPigSpritesUseCase) {
+ load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
ContainerController controller = data != null
? data.retrieveContainerController()
: new ContainerController(dropController, gameItemsHolder);
@GameScope
public static MobsController provideMobsController(MainConfig mainConfig,
GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager) {
- load(mainConfig, gameItemsHolder, tooltipManager);
+ TooltipManager tooltipManager,
+ GetPlayerSpritesUseCase getPlayerSpritesUseCase,
+ GetPigSpritesUseCase getPigSpritesUseCase) {
+ load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
MobsController controller = data != null
? data.retrieveMobsController()
- : new MobsController(gameItemsHolder, tooltipManager);
+ : new MobsController(gameItemsHolder, tooltipManager, getPlayerSpritesUseCase);
makeDataNullIfEmpty();
controller.getPlayer().initInventory(gameItemsHolder, tooltipManager);
return controller;
MobsController mobsController,
GameItemsHolder gameItemsHolder,
ContainerController containerController,
- TooltipManager tooltipManager) {
- load(mainConfig, gameItemsHolder, tooltipManager);
+ TooltipManager tooltipManager,
+ GetPlayerSpritesUseCase getPlayerSpritesUseCase,
+ GetPigSpritesUseCase getPigSpritesUseCase) {
+ load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
Block[][] fm = data != null ? data.retrieveForeMap() : null;
Block[][] bm = data != null ? data.retrieveBackMap() : null;
makeDataNullIfEmpty();
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
-import com.badlogic.gdx.utils.ObjectMap;
import com.badlogic.gdx.utils.TimeUtils;
import org.jetbrains.annotations.Nullable;
import ru.deadsoftware.cavedroid.MainConfig;
import ru.deadsoftware.cavedroid.game.input.mapper.MouseInputActionMapper;
import ru.deadsoftware.cavedroid.game.mobs.MobsController;
import ru.deadsoftware.cavedroid.game.mobs.player.Player;
-import ru.deadsoftware.cavedroid.game.objects.TouchButton;
import ru.deadsoftware.cavedroid.game.render.IGameRenderer;
import ru.deadsoftware.cavedroid.game.ui.TooltipManager;
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager;
import ru.deadsoftware.cavedroid.game.world.GameWorld;
-import ru.deadsoftware.cavedroid.misc.Assets;
import ru.deadsoftware.cavedroid.misc.Renderer;
-import ru.deadsoftware.cavedroid.misc.utils.MeasureUnitsUtilsKt;
import ru.deadsoftware.cavedroid.misc.utils.RenderingUtilsKt;
+import ru.fredboy.cavedroid.domain.assets.model.TouchButton;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTouchButtonsUseCase;
+import ru.fredboy.cavedroid.utils.MeasureUnitsUtilsKt;
import javax.inject.Inject;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
@GameScope
public class GameRenderer extends Renderer {
private static final float CAMERA_SPEED = 72f;
private static final float MAX_CAM_DISTANCE_FROM_PLAYER = 64f;
private static final float DRAG_THRESHOLD = 1f;
- private static final TouchButton nullButton = new TouchButton(null, -1, true);
+ private static final TouchButton nullButton = new TouchButton(new Rectangle(), -1, true);
private final MainConfig mMainConfig;
private final MobsController mMobsController;
private final Set<IKeyboardInputHandler> mKeyboardInputHandlers;
private final GameWindowsManager mGameWindowsManager;
private final TooltipManager mTooltipManager;
+ private final GetFontUseCase mGetFontUseCase;
+ private final GetTouchButtonsUseCase mGetTouchButtonsUseCase;
private final TouchButton mouseLeftTouchButton, mouseRightTouchButton;
Set<IMouseInputHandler> mouseInputHandlers,
Set<IKeyboardInputHandler> keyboardInputHandlers,
GameWindowsManager gameWindowsManager,
- TooltipManager tooltipManager) {
+ TooltipManager tooltipManager,
+ GetFontUseCase getFontUseCase,
+ GetTouchButtonsUseCase getTouchButtonsUseCase) {
super(mainConfig.getWidth(), mainConfig.getHeight());
mMainConfig = mainConfig;
mKeyboardInputHandlers = keyboardInputHandlers;
mGameWindowsManager = gameWindowsManager;
mTooltipManager = tooltipManager;
+ mGetFontUseCase = getFontUseCase;
+ mGetTouchButtonsUseCase = getTouchButtonsUseCase;
mouseLeftTouchButton = new TouchButton(new Rectangle(getWidth() / 2, 0f, getWidth() / 2, getHeight() / 2), Input.Buttons.LEFT, true);
mouseRightTouchButton = new TouchButton(new Rectangle(getWidth() / 2, getHeight() / 2, getWidth() / 2, getHeight() / 2), Input.Buttons.RIGHT, true);
mCursorMouseInputHandler.handle(action);
if (!mTooltipManager.getCurrentMouseTooltip().isEmpty()) {
- RenderingUtilsKt.drawString(spriter, mTooltipManager.getCurrentMouseTooltip(), screenX + 1, screenY + 1, Color.BLACK);
- RenderingUtilsKt.drawString(spriter, mTooltipManager.getCurrentMouseTooltip(), screenX, screenY, Color.WHITE);
+ RenderingUtilsKt.drawString(spriter, mGetFontUseCase.invoke(),
+ mTooltipManager.getCurrentMouseTooltip(), screenX + 1, screenY + 1, Color.BLACK);
+ RenderingUtilsKt.drawString(spriter, mGetFontUseCase.invoke(),
+ mTooltipManager.getCurrentMouseTooltip(), screenX, screenY, Color.WHITE);
}
}
if (mGameWindowsManager.getCurrentWindowType() != GameUiWindow.NONE) {
return nullButton;
}
- for (ObjectMap.Entry<String, TouchButton> entry : Assets.guiMap) {
- TouchButton button = entry.value;
- if (button.getRect().contains(touchX, touchY)) {
+ for (Map.Entry<String, TouchButton> entry : mGetTouchButtonsUseCase.invoke().entrySet()) {
+ TouchButton button = entry.getValue();
+ if (button.getRectangle().contains(touchX, touchY)) {
return button;
}
}
- if (mouseLeftTouchButton.getRect().contains(touchX, touchY)) {
+ if (mouseLeftTouchButton.getRectangle().contains(touchX, touchY)) {
return mouseLeftTouchButton;
}
- if (mouseRightTouchButton.getRect().contains(touchX, touchY)) {
+ if (mouseRightTouchButton.getRectangle().contains(touchX, touchY)) {
return mouseRightTouchButton;
}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game;
-
-import javax.inject.Scope;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-@Scope
-@Retention(RetentionPolicy.RUNTIME)
-public @interface GameScope {
-}
\ No newline at end of file
import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
import ru.deadsoftware.cavedroid.game.world.GameWorld;
import ru.deadsoftware.cavedroid.misc.Saveable;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase;
import java.util.Collections;
import java.util.List;
@Override
public abstract SaveDataDto.MobSaveDataDto getSaveData();
- public static Mob fromSaveData(SaveDataDto.MobSaveDataDto saveData) {
- return MobSaveDataMapperKt.fromSaveData(saveData);
+ public static Mob fromSaveData(SaveDataDto.MobSaveDataDto saveData,
+ GetPigSpritesUseCase getPigSpritesUseCase) {
+ return MobSaveDataMapperKt.fromSaveData(saveData, getPigSpritesUseCase);
}
}
package ru.deadsoftware.cavedroid.game.mobs.player;
+import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.MathUtils;
import ru.deadsoftware.cavedroid.misc.Assets;
import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin;
import ru.deadsoftware.cavedroid.misc.utils.SpriteUtilsKt;
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPlayerSpritesUseCase;
public class Player extends Mob {
private float hitAnim = 0f;
private float hitAnimDelta = ANIMATION_SPEED;
+ private MobSprite.Player playerSprite;
+
public Inventory inventory;
public int gameMode;
CURSOR
}
- public Player(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
+ public Player(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager, MobSprite.Player playerSprite) {
super(0, 0, 4, 30, randomDir(), Type.MOB, MAX_HEALTH);
+ this.playerSprite = playerSprite;
inventory = new Inventory(INVENTORY_SIZE, HOTBAR_SIZE, gameItemsHolder, tooltipManager);
swim = false;
}
sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
}
- final float handLength = Assets.playerSprite[0][2].getHeight();
+ final float handLength = playerSprite.getHand().getHeight();
final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
final int handMultiplier = -getDirection().getBasis();
@Override
public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
- final Sprite backHand = Assets.playerSprite[1][2];
- final Sprite backLeg = Assets.playerSprite[1][3];
- final Sprite frontLeg = Assets.playerSprite[0][3];
- final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
- final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
- final Sprite frontHand = Assets.playerSprite[0][2];
+ final Sprite hand = playerSprite.getHand();
+ final Sprite leg = playerSprite.getLeg();
+ final Sprite head = playerSprite.getHead();
+ final Sprite body = playerSprite.getBody();
+
+ hand.setFlip(looksRight(), hand.isFlipY());
+ leg.setFlip(looksRight(), leg.isFlipY());
+ head.setFlip(looksRight(), head.isFlipY());
+ body.setFlip(looksRight(), body.isFlipY());
+
+ hand.setOrigin(hand.getWidth() / 2, 0);
+ leg.setOrigin(leg.getWidth() / 2, 0);
+ head.setOrigin(head.getWidth() / 2, head.getHeight());
float backHandAnim, frontHandAnim;
frontHandAnim = -rightHandAnim;
}
- backHand.setColor(getTintColor());
- backLeg.setColor(getTintColor());
- frontLeg.setColor(getTintColor());
- head.setColor(getTintColor());
- body.setColor(getTintColor());
- frontHand.setColor(getTintColor());
+ final Color backgroundTintColor = getTintColor().cpy().sub(new Color(0xAAAAAA00));
- SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
+ hand.setColor(backgroundTintColor);
+ SpriteUtilsKt.drawSprite(spriteBatch, hand, x + 2, y + 8, backHandAnim);
if (looksLeft()) {
drawItem(spriteBatch, x, y, -backHandAnim);
}
- SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
- SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
+ leg.setColor(backgroundTintColor);
+ SpriteUtilsKt.drawSprite(spriteBatch, leg, x + 2, y + 20, mAnim);
+
+ leg.setColor(getTintColor());
+ SpriteUtilsKt.drawSprite(spriteBatch, leg, x + 2, y + 20, -mAnim);
+
+ head.setColor(getTintColor());
SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
+
+ body.setColor(getTintColor());
SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
if (looksRight()) {
drawItem(spriteBatch, x, y, frontHandAnim);
}
- SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
+ hand.setColor(getTintColor());
+ SpriteUtilsKt.drawSprite(spriteBatch, hand, x + 2, y + 8, frontHandAnim);
}
@NotNull
public static Player fromSaveData(
SaveDataDto.PlayerSaveData saveData,
GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager
+ TooltipManager tooltipManager,
+ GetPlayerSpritesUseCase getPlayerSpritesUseCase
) {
saveData.verifyVersion(SAVE_DATA_VERSION);
- Player player = new Player(gameItemsHolder, tooltipManager);
+ Player player = new Player(gameItemsHolder, tooltipManager, getPlayerSpritesUseCase.invoke());
player.mType = saveData.getType();
player.mAnimDelta = saveData.getAnimDelta();
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.objects;
-
-import com.badlogic.gdx.math.Rectangle;
-
-public class TouchButton {
-
- private final Rectangle rect;
- private final int code;
- private final boolean mouse;
-
- public TouchButton(Rectangle rect, int code, boolean mouse) {
- this.rect = rect;
- this.code = code;
- this.mouse = mouse;
- }
-
- public Rectangle getRect() {
- return rect;
- }
-
- public int getCode() {
- return code;
- }
-
- public boolean isMouse() {
- return mouse;
- }
-
-}
package ru.deadsoftware.cavedroid.game.world;
-import com.badlogic.gdx.math.MathUtils;
import kotlin.Pair;
import org.jetbrains.annotations.Nullable;
import ru.deadsoftware.cavedroid.game.GameItemsHolder;
import ru.deadsoftware.cavedroid.game.GameScope;
import ru.deadsoftware.cavedroid.game.mobs.MobsController;
-import ru.deadsoftware.cavedroid.game.mobs.Pig;
import ru.deadsoftware.cavedroid.game.model.block.Block;
import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
import ru.deadsoftware.cavedroid.game.model.item.Item;
import ru.deadsoftware.cavedroid.game.model.world.generator.WorldGeneratorConfig;
import ru.deadsoftware.cavedroid.game.objects.container.Container;
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
-import ru.deadsoftware.cavedroid.game.objects.container.Furnace;
import ru.deadsoftware.cavedroid.game.objects.container.ContainerController;
-import ru.deadsoftware.cavedroid.misc.utils.MeasureUnitsUtilsKt;
+import ru.deadsoftware.cavedroid.game.objects.container.Furnace;
+import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
+import ru.fredboy.cavedroid.utils.MeasureUnitsUtilsKt;
import javax.inject.Inject;
}
private void spawnInitialMobs() {
- for (int x = 0; x < getWidth(); x++) {
- int y = 0;
- while (y < getWorldConfig().getSeaLevel()) {
- if (getForeMap(x, y) == mGameItemsHolder.getBlock("grass")) {
- if (MathUtils.randomBoolean(.125f)) {
- mMobsController.addMob(new Pig(MeasureUnitsUtilsKt.getPx(x), MeasureUnitsUtilsKt.getPx(y)));
- }
- break;
- }
- y++;
- }
- }
+// for (int x = 0; x < getWidth(); x++) {
+// int y = 0;
+// while (y < getWorldConfig().getSeaLevel()) {
+// if (getForeMap(x, y) == mGameItemsHolder.getBlock("grass")) {
+// if (MathUtils.randomBoolean(.125f)) {
+// mMobsController.addMob(new Pig(MeasureUnitsUtilsKt.getPx(x), MeasureUnitsUtilsKt.getPx(y)));
+// }
+// break;
+// }
+// y++;
+// }
+// }
}
public void destroyForeMap(int x, int y) {
package ru.deadsoftware.cavedroid.menu;
import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.utils.ObjectMap;
import ru.deadsoftware.cavedroid.CaveGame;
import ru.deadsoftware.cavedroid.MainConfig;
import ru.deadsoftware.cavedroid.menu.objects.Button;
import ru.deadsoftware.cavedroid.menu.submenus.*;
import ru.deadsoftware.cavedroid.misc.Renderer;
+import ru.deadsoftware.cavedroid.misc.utils.RenderingUtilsKt;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase;
import javax.inject.Inject;
private final MenuNewGame mMenuNewGame;
private final MenuOptions mMenuOptions;
+ private final GetFontUseCase mGetFontUseCase;
+ private final GetStringWidthUseCase mGetStringWidthUseCase;
+ private final GetStringHeightUseCase mGetStringHeightUseCase;
+
+ private final GetTextureRegionByNameUseCase mGetTextureRegionByNameUseCase;
+
private Menu mCurrentMenu;
@Inject
public MenuProc(
MainConfig mainConfig,
- MenusFactory menusFactory
+ MenusFactory menusFactory,
+ GetFontUseCase getFontUseCase,
+ GetStringWidthUseCase getStringWidthUseCase,
+ GetStringHeightUseCase getStringHeightUseCase,
+ GetTextureRegionByNameUseCase getTextureRegionByNameUseCase
) {
super(mainConfig.getWidth(), mainConfig.getHeight());
mMainConfig = mainConfig;
+ mGetFontUseCase = getFontUseCase;
+ mGetStringWidthUseCase = getStringWidthUseCase;
+ mGetStringHeightUseCase = getStringHeightUseCase;
+ mGetTextureRegionByNameUseCase = getTextureRegionByNameUseCase;
Input menuInput = new Input();
}
private void drawButton(Button button) {
- spriter.draw(textureRegions.get("button_" + button.getType()), button.getX(), button.getY());
- setFontColor(255, 255, 255);
+ spriter.draw(mGetTextureRegionByNameUseCase.get("button_" + button.getType()), button.getX(), button.getY());
String label = processVariables(button.getLabel());
- drawString(label,
- (button.getX() + button.getWidth() / 2) - (float) getStringWidth(label) / 2,
- (button.getY() + button.getHeight() / 2) - (float) getStringHeight(label) / 2);
+ RenderingUtilsKt.drawString(spriter, mGetFontUseCase.invoke(), label,
+ (button.getX() + button.getWidth() / 2) - mGetStringWidthUseCase.invoke(label) / 2,
+ (button.getY() + button.getHeight() / 2) - mGetStringHeightUseCase.invoke(label) / 2);
}
@Override
public void render(float delta) {
spriter.begin();
mCurrentMenu.draw(spriter);
- drawString("CaveDroid " + CaveGame.VERSION, 0,
- getHeight() - getStringHeight("CaveDroid " + CaveGame.VERSION) * 1.5f);
+ RenderingUtilsKt.drawString(spriter, mGetFontUseCase.invoke(), "CaveDroid " + CaveGame.VERSION, 0,
+ getHeight() - mGetStringHeightUseCase.invoke("CaveDroid " + CaveGame.VERSION) * 1.5f);
spriter.end();
}
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
import ru.deadsoftware.cavedroid.misc.Assets;
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase;
import java.util.HashMap;
protected final MenuProc.Input mMenuInput;
protected final AssetLoader mAssetLoader;
+ protected final GetTextureRegionByNameUseCase mGetTextureRegionByNameUseCase;
+
private final ButtonRenderer mButtonRenderer;
private final float mWidth;
ButtonRenderer buttonRenderer,
MainConfig mainConfig,
MenuProc.Input menuInput,
- AssetLoader assetLoader) {
+ AssetLoader assetLoader,
+ GetTextureRegionByNameUseCase getTextureRegionByNameUseCase) {
mWidth = width;
mHeight = height;
mButtonRenderer = buttonRenderer;
mMainConfig = mainConfig;
mMenuInput = menuInput;
mAssetLoader = assetLoader;
+ mGetTextureRegionByNameUseCase = getTextureRegionByNameUseCase;
initButtons();
}
* @param spriter {@link SpriteBatch} that will draw it. Should be already started.
*/
public void draw(SpriteBatch spriter) {
- TextureRegion background = Assets.textureRegions.get("background");
- TextureRegion gamelogo = Assets.textureRegions.get("gamelogo");
+ TextureRegion background = mGetTextureRegionByNameUseCase.get("background");
+ TextureRegion gamelogo = mGetTextureRegionByNameUseCase.get("gamelogo");
for (int x = 0; x <= mWidth / 16; x++) {
for (int y = 0; y <= mHeight / 16; y++) {
import ru.deadsoftware.cavedroid.menu.objects.ButtonEventListener;
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase;
import javax.inject.Inject;
import java.util.HashMap;
ButtonRenderer buttonRenderer,
MainConfig mainConfig,
MenuProc.Input menuInput,
- AssetLoader assetLoader) {
- super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader);
+ AssetLoader assetLoader,
+ GetTextureRegionByNameUseCase getTextureRegionByNameUseCase) {
+ super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByNameUseCase);
}
@Override
}
}
- public static class Factory {
-
- private final MainConfig mMainConfig;
- private final AssetLoader mAssetLoader;
-
- @Inject
- public Factory(MainConfig mainConfig, AssetLoader assetLoader) {
- mMainConfig = mainConfig;
- mAssetLoader = assetLoader;
- }
-
- public MenuMain get(float width, float height, ButtonRenderer buttonRenderer, MenuProc.Input menuInput) {
- return new MenuMain(width, height, buttonRenderer, mMainConfig, menuInput, mAssetLoader);
- }
-
- }
-
}
import ru.deadsoftware.cavedroid.menu.objects.ButtonEventListener;
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase;
import javax.inject.Inject;
import java.util.HashMap;
ButtonRenderer buttonRenderer,
MainConfig mainConfig,
MenuProc.Input menuInput,
- AssetLoader assetLoader) {
- super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader);
+ AssetLoader assetLoader,
+ GetTextureRegionByNameUseCase getTextureRegionByNameUseCase) {
+ super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByNameUseCase);
}
@Override
loadButtonsFromJson(mAssetLoader.getAssetHandle("json/menu_new_game_buttons.json"));
}
- public static class Factory {
-
- private final MainConfig mMainConfig;
- private final AssetLoader mAssetLoader;
-
- @Inject
- public Factory(MainConfig mainConfig, AssetLoader assetLoader) {
- mMainConfig = mainConfig;
- mAssetLoader = assetLoader;
- }
-
- public MenuNewGame get(float width, float height, ButtonRenderer buttonRenderer, MenuProc.Input menuInput) {
- return new MenuNewGame(width, height, buttonRenderer, mMainConfig, menuInput, mAssetLoader);
- }
-
- }
}
package ru.deadsoftware.cavedroid.misc;
-import com.badlogic.gdx.Input;
-import com.badlogic.gdx.files.FileHandle;
-import com.badlogic.gdx.graphics.Texture;
-import com.badlogic.gdx.graphics.g2d.BitmapFont;
-import com.badlogic.gdx.graphics.g2d.GlyphLayout;
-import com.badlogic.gdx.graphics.g2d.Sprite;
-import com.badlogic.gdx.graphics.g2d.TextureRegion;
-import com.badlogic.gdx.math.Rectangle;
-import com.badlogic.gdx.utils.ArrayMap;
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonValue;
-import ru.deadsoftware.cavedroid.game.objects.TouchButton;
-import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
-import java.io.File;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
public class Assets {
- private static final int BLOCK_DAMAGE_STAGES = 10;
public static final JsonReader jsonReader = new JsonReader();
- private static final List<Texture> loadedTextures = new LinkedList<>();
-
- public static final Sprite[][] playerSprite = new Sprite[2][4];
- public static final Sprite[][] pigSprite = new Sprite[2][2];
-
- public static final Sprite[] blockDamageSprites = new Sprite[10];
-
- public static final HashMap<String, TextureRegion> textureRegions = new HashMap<>();
- public static final ArrayMap<String, TouchButton> guiMap = new ArrayMap<>();
- private static final GlyphLayout glyphLayout = new GlyphLayout();
- public static BitmapFont minecraftFont;
-
- public static Map<String, Texture> blockTextures = new HashMap<>();
- public static Map<String, Texture> itemTextures = new HashMap<>();
-
- public static Sprite joyBackground;
- public static Sprite joyStick;
-
- public static Sprite furnaceBurn;
- public static Sprite furnaceProgress;
-
- public static void dispose() {
- minecraftFont.dispose();
- for (Texture texture : loadedTextures) {
- texture.dispose();
- }
- loadedTextures.clear();
- }
-
- private static Texture loadTexture(FileHandle fileHandle) {
- Texture texture = new Texture(fileHandle);
- loadedTextures.add(texture);
- return texture;
- }
-
- private static TextureRegion flippedRegion(Texture texture, int x, int y, int width, int height) {
- return new TextureRegion(texture, x, y + height, width, -height);
- }
-
- private static Sprite flippedSprite(Texture texture) {
- Sprite sprite = new Sprite(texture);
- sprite.flip(false, true);
- return sprite;
- }
-
- private static Sprite flippedSprite(TextureRegion texture) {
- Sprite sprite = new Sprite(texture);
- sprite.flip(false, true);
- return sprite;
- }
-
- private static void loadMob(AssetLoader assetLoader, Sprite[][] sprite, String mob) {
- for (int i = 0; i < sprite.length; i++) {
- for (int j = 0; j < sprite[i].length; j++) {
- sprite[i][j] = flippedSprite(loadTexture(
- assetLoader.getAssetHandle("pp/mobs/" + mob + "/" + i + "_" + j + ".png")));
- sprite[i][j].setOrigin(sprite[i][j].getWidth() / 2, 0);
- }
- }
- }
-
- private static void loadBlockDamage(AssetLoader assetLoader) {
- final Texture blockDamageTexture = loadTexture(assetLoader.getAssetHandle("pp/break.png"));
- for (int i = 0; i < BLOCK_DAMAGE_STAGES; i++) {
- blockDamageSprites[i] = new Sprite(flippedRegion(blockDamageTexture, i * 16, 0, 16, 16));
- }
- }
-
- private static void setPlayerHeadOrigin() {
- for (Sprite[] sprites : playerSprite) {
- sprites[0].setOrigin(sprites[0].getWidth() / 2, sprites[0].getHeight());
- }
- }
-
- /**
- * Loads texture names and sizes from <b>json/texture_regions.json</b>, cuts them to TextureRegions
- * and puts to {@link #textureRegions} HashMap
- */
- private static void loadJSON(AssetLoader assetLoader) {
- JsonValue json = jsonReader.parse(assetLoader.getAssetHandle("json/texture_regions.json"));
- for (JsonValue file = json.child(); file != null; file = file.next()) {
- Texture texture = loadTexture(assetLoader.getAssetHandle(file.name() + ".png"));
- final String[] pathSegments = file.name().split("/");
- final String name = pathSegments[pathSegments.length - 1];
- if (file.size == 0) {
- textureRegions.put(name, flippedRegion(texture, 0, 0, texture.getWidth(), texture.getHeight()));
- } else {
- for (JsonValue key = file.child(); key != null; key = key.next()) {
- int x = getIntFromJson(key, "x", 0);
- int y = getIntFromJson(key, "y", 0);
- int w = getIntFromJson(key, "w", texture.getWidth());
- int h = getIntFromJson(key, "h", texture.getHeight());
- textureRegions.put(key.name(), flippedRegion(texture, x, y, w, h));
- }
- }
- }
- }
-
- private static int getMouseKey(String name) {
- switch (name) {
- case "Left":
- return Input.Buttons.LEFT;
- case "Right":
- return Input.Buttons.RIGHT;
- case "Middle":
- return Input.Buttons.MIDDLE;
- case "Back":
- return Input.Buttons.BACK;
- case "Forward":
- return Input.Buttons.FORWARD;
- default:
- return -1;
- }
- }
-
- private static void loadTouchButtonsFromJSON(AssetLoader assetLoader) {
- JsonValue json = Assets.jsonReader.parse(assetLoader.getAssetHandle("json/touch_buttons.json"));
- for (JsonValue key = json.child(); key != null; key = key.next()) {
- float x = key.getFloat("x");
- float y = key.getFloat("y");
- float w = key.getFloat("w");
- float h = key.getFloat("h");
- boolean mouse = Assets.getBooleanFromJson(key, "mouse", false);
- String name = key.getString("key");
- int code = mouse ? getMouseKey(name) : Input.Keys.valueOf(name);
- if (x < 0) {
- x = assetLoader.getGameRendererWidth() + x;
- }
- if (y < 0) {
- y = assetLoader.getGameRendererHeight() + y;
- }
- Assets.guiMap.put(key.name(), new TouchButton(new Rectangle(x, y, w, h), code, mouse));
- }
-
- }
-
- private static Texture resolveTexture(AssetLoader assetLoader, String textureName, String lookUpPath, Map<String, Texture> cache) {
- if (cache.containsKey(textureName)) {
- return cache.get(textureName);
- }
-
- final Texture texture = loadTexture(assetLoader.getAssetHandle(lookUpPath + File.separator + textureName + ".png"));
- cache.put(textureName, texture);
-
- return texture;
- }
-
- public static Texture resolveItemTexture(AssetLoader assetLoader, String textureName) {
- return resolveTexture(assetLoader, textureName, "pp/textures/items", itemTextures);
- }
-
- public static Texture resolveBlockTexture(AssetLoader assetLoader, String textureName) {
- return resolveTexture(assetLoader, textureName, "pp/textures/blocks", blockTextures);
- }
-
- private static void loadAllPngsFromDirInto(FileHandle dir, Map<String, Texture> loadInto) {
- for (FileHandle handle : dir.list((d, name) -> name.endsWith(".png"))) {
- loadInto.put(handle.nameWithoutExtension(), loadTexture(handle));
- }
- }
-
- private static void loadItems(AssetLoader assetLoader) {
- final FileHandle itemsDir = assetLoader.getAssetHandle("pp/textures/items");
- loadAllPngsFromDirInto(itemsDir, itemTextures);
- }
-
- private static void loadBlocks(AssetLoader assetLoader) {
- final FileHandle blocksDir = assetLoader.getAssetHandle("pp/textures/blocks");
- loadAllPngsFromDirInto(blocksDir, blockTextures);
- }
-
- private static void loadJoystick(AssetLoader assetLoader) {
- joyStick = new Sprite(loadTexture(assetLoader.getAssetHandle("joy_stick.png")));
- joyBackground = new Sprite(loadTexture(assetLoader.getAssetHandle("joy_background.png")));
- }
-
- private static void loadFurnace(AssetLoader assetLoader) {
- furnaceBurn = new Sprite(textureRegions.get("furnace_burn"));
- furnaceProgress = new Sprite(textureRegions.get("furnace_progress"));
- }
-
- public static void load(final AssetLoader assetLoader) {
- loadMob(assetLoader, playerSprite, "char");
- loadMob(assetLoader, pigSprite, "pig");
- loadBlockDamage(assetLoader);
- loadJSON(assetLoader);
- loadBlocks(assetLoader);
- loadItems(assetLoader);
- loadTouchButtonsFromJSON(assetLoader);
- loadJoystick(assetLoader);
- loadFurnace(assetLoader);
- setPlayerHeadOrigin();
- minecraftFont = new BitmapFont(assetLoader.getAssetHandle("font.fnt"), true);
- minecraftFont.getData().setScale(.375f);
- minecraftFont.setUseIntegerPositions(false);
- }
-
- /**
- * @param s string whose width you want to know
- * @return A width of string written in {@link #minecraftFont} in pixels
- */
- public static int getStringWidth(String s) {
- glyphLayout.setText(minecraftFont, s);
- return (int) glyphLayout.width;
- }
-
- /**
- * @param s string whose height you want to know
- * @return A height of string written in {@link #minecraftFont} in pixels
- */
- public static int getStringHeight(String s) {
- glyphLayout.setText(minecraftFont, s);
- return (int) glyphLayout.height;
- }
public static int getIntFromJson(JsonValue json, String name, int defaultValue) {
return json.has(name) ? json.getInt(name) : defaultValue;
}
- public static float getFloatFromJson(JsonValue json, String name, float defaultValue) {
- return json.has(name) ? json.getFloat(name) : defaultValue;
- }
public static String getStringFromJson(JsonValue json, String name, String defaultValue) {
return json.has(name) ? json.getString(name) : defaultValue;
return mCameraViewport;
}
- public void setFontScale(float scale) {
- Assets.minecraftFont.getData().setScale(scale);
- }
-
- protected void setFontColor(int r, int g, int b) {
- Assets.minecraftFont.setColor(r / 255f, g / 255f, b / 255f, 1f);
- }
-
- protected void drawString(String str, float x, float y) {
- Assets.minecraftFont.draw(spriter, str, x, y);
- }
-
- protected void drawString(String str) {
- Assets.minecraftFont.draw(spriter, str,
- getWidth() / 2 - (float) Assets.getStringWidth(str) / 2,
- getHeight() / 2 - (float) Assets.getStringHeight(str) / 2);
- }
-
public abstract void render(float delta);
@Override
Gdx.files.absolute(gameDataDirectoryPath).mkdirs()
initMainConfig()
- Assets.load(assetLoader)
+ mainComponent.initializeAssetsUseCase()
setScreen(mainComponent.menuScreen)
}
override fun dispose() {
screen?.dispose()
- Assets.dispose()
+ mainComponent.disposeAssetsUseCase()
}
import ru.deadsoftware.cavedroid.menu.MenuScreen
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
import ru.deadsoftware.cavedroid.prefs.PreferencesStore
+import ru.fredboy.cavedroid.data.assets.di.DataAssetsModule
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import ru.fredboy.cavedroid.domain.assets.repository.*
+import ru.fredboy.cavedroid.domain.assets.usecase.DisposeAssetsUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.InitializeAssetsUseCase
import javax.inject.Singleton
@Singleton
-@Component(dependencies = [CaveGame::class, PreferencesStore::class])
+@Component(
+ dependencies = [CaveGame::class, PreferencesStore::class],
+ modules = [DataAssetsModule::class]
+)
interface MainComponent {
val gameScreen: GameScreen
val assetLoader: AssetLoader
+ val initializeAssetsUseCase: InitializeAssetsUseCase
+
+ val disposeAssetsUseCase: DisposeAssetsUseCase
+
+ val blockAssetsRepository: BlockAssetsRepository
+
+ val blockDamageAssetsRepository: BlockDamageAssetsRepository
+
+ val fontAssetsRepository: FontAssetsRepository
+
+ val mobAssetsRepository: MobAssetsRepository
+
+ val itemAssetsRepository: ItemsAssetsRepository
+
+ val textureRegionsAssetsRepository: TextureRegionsAssetsRepository
+
+ val touchButtonsAssetsRepository: TouchButtonsAssetsRepository
+
}
\ No newline at end of file
--- /dev/null
+package ru.deadsoftware.cavedroid.game
+
+import javax.inject.Scope
+
+@Scope
+@Retention(AnnotationRetention.RUNTIME)
+annotation class GameScope
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
import ru.deadsoftware.cavedroid.game.mobs.Pig
import ru.deadsoftware.cavedroid.game.model.item.Item
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
class UsePigSpawnEggAction @Inject constructor(
private val mobsController: MobsController,
private val gameItemsHolder: GameItemsHolder,
+ private val getPigSprites: GetPigSpritesUseCase,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
- Pig(mobsController.player.cursorX.px, mobsController.player.cursorY.px)
+ Pig(getPigSprites(), mobsController.player.cursorX.px, mobsController.player.cursorY.px)
.apply {
attachToController(mobsController)
}
package ru.deadsoftware.cavedroid.game.input
import com.badlogic.gdx.graphics.g2d.TextureRegion
-import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
-import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
-fun isInsideHotbar(action: MouseInputAction): Boolean {
- val hotbar = requireNotNull(Assets.textureRegions["hotbar"])
+fun MouseInputAction.isInsideHotbar(getTextureRegionByNameUseCase: GetTextureRegionByNameUseCase): Boolean {
+ val hotbar = requireNotNull(getTextureRegionByNameUseCase["hotbar"])
- return action.screenY <= hotbar.regionHeight &&
- action.screenX >= action.cameraViewport.width / 2 - hotbar.regionWidth / 2 &&
- action.screenX <= action.cameraViewport.width / 2 + hotbar.regionWidth / 2
+ return this.screenY <= hotbar.regionHeight &&
+ this.screenX >= this.cameraViewport.width / 2 - hotbar.regionWidth / 2 &&
+ this.screenX <= this.cameraViewport.width / 2 + hotbar.regionWidth / 2
}
fun isInsideWindow(action: MouseInputAction, windowTexture: TextureRegion): Boolean {
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.world.GameWorld
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
class AttackMouseInputHandler @Inject constructor(
private val mobsController: MobsController,
private val gameWorld: GameWorld,
- private val gameWindowsManager: GameWindowsManager
+ private val gameWindowsManager: GameWindowsManager,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.getCurrentWindow() == GameUiWindow.NONE &&
- !isInsideHotbar(action) &&
+ !action.isInsideHotbar(textureRegions) &&
action.actionKey is MouseInputActionKey.Left
}
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.objects.drop.DropController
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
private val dropController: DropController,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
- private val creativeInventoryTexture get() = requireNotNull(Assets.textureRegions["creative"])
- private val survivalInventoryTexture get() = requireNotNull(Assets.textureRegions["survival"])
- private val craftingInventoryTexture get() = requireNotNull(Assets.textureRegions["crafting_table"])
- private val furnaceInventoryTexture get() = requireNotNull(Assets.textureRegions["furnace"])
- private val chestInventoryTexture get() = requireNotNull(Assets.textureRegions["chest"])
+ private val creativeInventoryTexture get() = requireNotNull(textureRegions["creative"])
+ private val survivalInventoryTexture get() = requireNotNull(textureRegions["survival"])
+ private val craftingInventoryTexture get() = requireNotNull(textureRegions["crafting_table"])
+ private val furnaceInventoryTexture get() = requireNotNull(textureRegions["furnace"])
+ private val chestInventoryTexture get() = requireNotNull(textureRegions["chest"])
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.getCurrentWindow() != GameUiWindow.NONE &&
gameWindowsManager.closeWindow()
}
-}
\ No newline at end of file
+}
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
import kotlin.math.abs
private val mainConfig: MainConfig,
private val gameWindowsManager: GameWindowsManager,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
- private val creativeInventoryTexture get() = requireNotNull(Assets.textureRegions["creative"])
+ private val creativeInventoryTexture get() = requireNotNull(textureRegions["creative"])
private var dragStartY = 0f
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.math.MathUtils
import ru.deadsoftware.cavedroid.MainConfig
import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.world.GameWorld
-import ru.deadsoftware.cavedroid.misc.Assets
-import ru.deadsoftware.cavedroid.misc.utils.bl
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.utils.bl
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val gameItemsHolder: GameItemsHolder,
private val tooltipManager: TooltipManager,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
private val player get() = mobsController.player
- private val creativeInventoryTexture get() = requireNotNull(Assets.textureRegions["creative"])
+ private val creativeInventoryTexture get() = requireNotNull(textureRegions["creative"])
private val Block.isAutoselectable
get() = !isNone() && params.hasCollision
import ru.deadsoftware.cavedroid.game.objects.drop.Drop
import ru.deadsoftware.cavedroid.game.objects.drop.DropController
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
private val dropController: DropController,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
- private val hotbarTexture get() = requireNotNull(Assets.textureRegions["hotbar"])
+ private val hotbarTexture get() = requireNotNull(textureRegions["hotbar"])
private var buttonHoldTask: Timer.Task? = null
override fun checkConditions(action: MouseInputAction): Boolean {
return buttonHoldTask?.isScheduled == true ||
((action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen)
- && isInsideHotbar(action)
+ && action.isInsideHotbar(textureRegions)
|| action.actionKey is MouseInputActionKey.Scroll) &&
gameWindowsManager.getCurrentWindow() == GameUiWindow.NONE
}
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.ChestInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.CHEST) {
- override val windowTexture get() = requireNotNull(Assets.textureRegions["chest"])
+ override val windowTexture get() = requireNotNull(textureRegions["chest"])
private fun handleInsideContentGrid(action: MouseInputAction, xOnGrid: Int, yOnGrid: Int) {
val window = gameWindowsManager.currentWindow as ChestInventoryWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.CraftingInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.CRAFTING_TABLE) {
- override val windowTexture get() = requireNotNull(Assets.textureRegions["crafting_table"])
+ override val windowTexture get() = requireNotNull(textureRegions["crafting_table"])
private fun handleInsideInventoryGrid(action: MouseInputAction, xOnGrid: Int, yOnGrid: Int) {
val window = gameWindowsManager.currentWindow as CraftingInventoryWindow
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameItemsHolder: GameItemsHolder,
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
- private val creativeInventoryTexture get() = requireNotNull(Assets.textureRegions["creative"])
+ private val creativeInventoryTexture get() = requireNotNull(textureRegions["creative"])
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.getCurrentWindow() == GameUiWindow.CREATIVE_INVENTORY &&
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.FurnaceInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.FURNACE) {
- override val windowTexture get() = requireNotNull(Assets.textureRegions["furnace"])
+ override val windowTexture get() = requireNotNull(textureRegions["furnace"])
private fun handleInsideInventoryGrid(action: MouseInputAction, xOnGrid: Int, yOnGrid: Int) {
val window = gameWindowsManager.currentWindow as FurnaceInventoryWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.SurvivalInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val mobsController: MobsController,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.SURVIVAL_INVENTORY) {
- override val windowTexture get() = requireNotNull(Assets.textureRegions["survival"])
+ override val windowTexture get() = requireNotNull(textureRegions["survival"])
private fun handleInsideInventoryGrid(action: MouseInputAction, xOnGrid: Int, yOnGrid: Int) {
val window = gameWindowsManager.currentWindow as SurvivalInventoryWindow
import ru.deadsoftware.cavedroid.game.model.item.Item
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.world.GameWorld
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val gameWindowsManager: GameWindowsManager,
private val gameWorld: GameWorld,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
private var buttonHoldTask: Timer.Task? = null
override fun checkConditions(action: MouseInputAction): Boolean {
return buttonHoldTask?.isScheduled == true ||
- !isInsideHotbar(action) &&
+ !action.isInsideHotbar(textureRegions) &&
gameWindowsManager.getCurrentWindow() == GameUiWindow.NONE &&
action.actionKey is MouseInputActionKey.Right
}
import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.world.GameWorld
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val mobsController: MobsController,
private val gameWindowsManager: GameWindowsManager,
private val gameWorld: GameWorld,
+ private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
private var activateTimeMs = 0L
(action.actionKey.pointer == mainConfig.joystick?.pointer || !active) &&
((action.actionKey is MouseInputActionKey.Dragged) ||
(action.screenX < action.cameraViewport.width / 2 && !action.actionKey.touchUp || active)) &&
- !(action.actionKey is MouseInputActionKey.Screen && isInsideHotbar(action))
+ !(action.actionKey is MouseInputActionKey.Screen && action.isInsideHotbar(textureRegions))
}
import ru.deadsoftware.cavedroid.game.model.block.Block
import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
import ru.deadsoftware.cavedroid.game.world.GameWorld
-import ru.deadsoftware.cavedroid.misc.utils.bl
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.utils.bl
+import ru.fredboy.cavedroid.utils.px
class FallingBlock(
private val blockKey: String,
package ru.deadsoftware.cavedroid.game.mobs
import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
-fun fromSaveData(saveData: SaveDataDto.MobSaveDataDto): Mob {
+fun fromSaveData(
+ saveData: SaveDataDto.MobSaveDataDto,
+ getPigSprites: GetPigSpritesUseCase,
+): Mob {
return when (saveData) {
- is SaveDataDto.PigSaveData -> Pig.fromSaveData(saveData)
+ is SaveDataDto.PigSaveData -> Pig.fromSaveData(getPigSprites, saveData)
is SaveDataDto.FallingBlockSaveData -> FallingBlock.fromSaveData(saveData)
is SaveDataDto.PlayerSaveData -> throw IllegalArgumentException("Cannot load player as regular Mob")
import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
import ru.deadsoftware.cavedroid.game.ui.TooltipManager
import ru.deadsoftware.cavedroid.misc.Saveable
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPlayerSpritesUseCase
import java.util.*
import javax.inject.Inject
class MobsController @Inject constructor(
gameItemsHolder: GameItemsHolder,
tooltipManager: TooltipManager,
+ getPlayerSprites: GetPlayerSpritesUseCase,
) : Saveable {
private val _mobs = LinkedList<Mob>()
- var player: Player = Player(gameItemsHolder, tooltipManager)
+ var player: Player = Player(gameItemsHolder, tooltipManager, getPlayerSprites())
private set
val mobs: List<Mob>
fun fromSaveData(
saveData: SaveDataDto.MobsControllerSaveData,
gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager
+ tooltipManager: TooltipManager,
+ getPigSprites: GetPigSpritesUseCase,
+ getPlayerSprites: GetPlayerSpritesUseCase,
): MobsController {
saveData.verifyVersion(SAVE_DATA_VERSION)
- return MobsController(gameItemsHolder, tooltipManager)
+ return MobsController(gameItemsHolder, tooltipManager, getPlayerSprites)
.apply {
- _mobs.addAll(saveData.mobs.map { mob -> Mob.fromSaveData(mob) })
- player = Player.fromSaveData(saveData.player, gameItemsHolder, tooltipManager)
+ _mobs.addAll(saveData.mobs.map { mob -> Mob.fromSaveData(mob, getPigSprites) })
+ player = Player.fromSaveData(saveData.player, gameItemsHolder, tooltipManager, getPlayerSprites)
}
}
}
package ru.deadsoftware.cavedroid.game.mobs
+import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.math.Vector2
import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
+import ru.deadsoftware.cavedroid.misc.utils.colorFromHexString
import ru.deadsoftware.cavedroid.misc.utils.drawSprite
-import ru.deadsoftware.cavedroid.misc.utils.mobs.MobSprites.Pig.getBackgroundLeg
-import ru.deadsoftware.cavedroid.misc.utils.mobs.MobSprites.Pig.getBody
-import ru.deadsoftware.cavedroid.misc.utils.mobs.MobSprites.Pig.getForegroundLeg
-import ru.deadsoftware.cavedroid.misc.utils.mobs.MobSprites.Pig.getLeftLegRelativeX
-import ru.deadsoftware.cavedroid.misc.utils.mobs.MobSprites.Pig.getLegsRelativeY
-import ru.deadsoftware.cavedroid.misc.utils.mobs.MobSprites.Pig.getRightLegRelativeX
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
-class Pig(x: Float, y: Float) : PeacefulMob(x, y, WIDTH, HEIGHT, randomDir(), MAX_HEALTH) {
+class Pig(
+ private val sprite: MobSprite.Pig,
+ x: Float,
+ y: Float
+) : PeacefulMob(x, y, WIDTH, HEIGHT, randomDir(), MAX_HEALTH) {
override fun getSpeed(): Float {
return SPEED
return listOf(gameItemsHolder.getItem("porkchop_raw").toInventoryItem())
}
- override fun draw(spriteBatch: SpriteBatch, x: Float, y: Float, delta: Float) {
+ override fun draw(
+ spriteBatch: SpriteBatch,
+ x: Float,
+ y: Float,
+ delta: Float
+ ) {
updateAnimation(delta)
- val leftLegX = x + getLeftLegRelativeX(direction)
- val rightLegX = x + getRightLegRelativeX(direction)
- val legY = y + getLegsRelativeY()
+ val leftLegX = x + sprite.getLeftLegRelativeX(direction.index)
+ val rightLegX = x + sprite.getRightLegRelativeX(direction.index)
+ val legY = y + sprite.getLegsRelativeY()
- spriteBatch.drawSprite(getBackgroundLeg(), leftLegX, legY, -anim, tint = tintColor)
- spriteBatch.drawSprite(getBackgroundLeg(), rightLegX, legY, -anim, tint = tintColor)
- spriteBatch.drawSprite(getBody(direction), x, y, tint = tintColor)
- spriteBatch.drawSprite(getForegroundLeg(), leftLegX, legY, anim, tint = tintColor)
- spriteBatch.drawSprite(getForegroundLeg(), rightLegX, legY, anim, tint = tintColor)
+ sprite.leg.setOrigin(sprite.leg.width / 2, 0f)
+ sprite.leg.setFlip(looksRight(), sprite.leg.isFlipY)
+ sprite.headAndBody.setFlip(looksRight(), sprite.leg.isFlipY)
+
+ val backgroundTintColor = tintColor.cpy().sub(Color(0xAAAAAA shl 8))
+
+ spriteBatch.drawSprite(sprite.leg, leftLegX, legY, -anim, tint = backgroundTintColor)
+ spriteBatch.drawSprite(sprite.leg, rightLegX, legY, -anim, tint = backgroundTintColor)
+ spriteBatch.drawSprite(sprite.headAndBody, x, y, tint = tintColor)
+ spriteBatch.drawSprite(sprite.leg, leftLegX, legY, anim, tint = tintColor)
+ spriteBatch.drawSprite(sprite.leg, rightLegX, legY, anim, tint = tintColor)
}
override fun getSaveData(): SaveDataDto.PigSaveData {
private const val JUMP_VELOCITY = -133.332f
private const val MAX_HEALTH = 10
- fun fromSaveData(saveData: SaveDataDto.PigSaveData): Pig {
+ fun fromSaveData(
+ getPigSprite: GetPigSpritesUseCase,
+ saveData: SaveDataDto.PigSaveData
+ ): Pig {
saveData.verifyVersion(SAVE_DATA_VERSION)
- return Pig(saveData.x, saveData.y).apply {
+ return Pig(getPigSprite(), saveData.x, saveData.y).apply {
velocity.x = saveData.velocityX
velocity.y = saveData.velocityY
mAnimDelta = saveData.animDelta
package ru.deadsoftware.cavedroid.game.model.item
import com.badlogic.gdx.graphics.Color
+import com.badlogic.gdx.graphics.g2d.BitmapFont
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.misc.Saveable
import ru.deadsoftware.cavedroid.misc.utils.drawSprite
import ru.deadsoftware.cavedroid.misc.utils.drawString
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.utils.px
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
return amount + count <= item.params.maxStack
}
- private fun drawAmountText(spriteBatch: SpriteBatch, text: String, x: Float, y: Float) {
- spriteBatch.drawString(text, x + 1, y + 1, Color.BLACK)
- spriteBatch.drawString(text, x, y, Color.WHITE)
+ private fun drawAmountText(spriteBatch: SpriteBatch, font: BitmapFont, text: String, x: Float, y: Float) {
+ spriteBatch.drawString(font, text, x + 1, y + 1, Color.BLACK)
+ spriteBatch.drawString(font, text, x, y, Color.WHITE)
}
- fun drawSelected(spriteBatch: SpriteBatch, x: Float, y: Float) {
+ fun drawSelected(
+ spriteBatch: SpriteBatch,
+ font: BitmapFont,
+ x: Float,
+ y: Float,
+ getStringWidth: GetStringWidthUseCase,
+ getStringHeight: GetStringHeightUseCase,
+ ) {
if (item.isNone()) {
return
}
spriteBatch.drawSprite(sprite, x - 10f, y - 10f, rotation = 0f, width = 20f, height = 20f)
drawAmountText(
spriteBatch = spriteBatch,
+ font = font,
text = amountString,
- x = x + 10f - Assets.getStringWidth(amountString) + 1f,
- y = y + 10f - Assets.getStringHeight(amountString) + 1f
+ x = x + 10f - getStringWidth(amountString) + 1f,
+ y = y + 10f - getStringHeight(amountString) + 1f
)
}
- fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, x: Float, y: Float) {
+ fun draw(
+ spriteBatch: SpriteBatch,
+ shapeRenderer: ShapeRenderer,
+ font: BitmapFont,
+ x: Float,
+ y: Float,
+ getStringWidth: GetStringWidthUseCase,
+ getStringHeight: GetStringHeightUseCase,
+ ) {
if (item.isNone()) {
return
}
val amountString = amount.toString()
drawAmountText(
spriteBatch = spriteBatch,
+ font = font,
text = amountString,
- x = x + 1.px - Assets.getStringWidth(amountString),
- y = y + 1.px - Assets.getStringHeight(amountString)
+ x = x + 1.px - getStringWidth(amountString),
+ y = y + 1.px - getStringHeight(amountString)
)
}
}
import ru.deadsoftware.cavedroid.game.model.item.Item
import ru.deadsoftware.cavedroid.misc.Assets
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockTextureUseCase
import javax.inject.Inject
@Reusable
class BlockMapper @Inject constructor(
private val assetLoader: AssetLoader,
+ private val getBlockTexture: GetBlockTextureUseCase,
) {
fun map(key: String, dto: BlockDto): Block {
return null
}
- return Assets.resolveBlockTexture(assetLoader, textureName)
+ return getBlockTexture[textureName]
}
}
\ No newline at end of file
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin
import ru.deadsoftware.cavedroid.misc.utils.colorFromHexString
+import ru.fredboy.cavedroid.domain.assets.usecase.GetItemTextureUseCase
import javax.inject.Inject
@Reusable
class ItemMapper @Inject constructor(
private val assetLoader: AssetLoader,
+ private val getItemTexture: GetItemTextureUseCase,
) {
fun map(key: String, dto: ItemDto, block: Block?, slabTopBlock: Block.Slab?, slabBottomBlock: Block.Slab?): Item {
return null
}
- val texture = Assets.resolveItemTexture(assetLoader, dto.texture)
+ val texture = getItemTexture[dto.texture]
return Sprite(texture)
.apply {
flip(false, true)
import ru.deadsoftware.cavedroid.game.model.item.InventoryItem.Companion.isNoneOrNull
import ru.deadsoftware.cavedroid.game.objects.drop.DropController
import ru.deadsoftware.cavedroid.misc.Saveable
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
import ru.deadsoftware.cavedroid.misc.utils.forEachBlockInArea
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
import javax.inject.Inject
@GameScope
@BindRenderer
class BackgroundBlocksRenderer @Inject constructor(
gameWorld: GameWorld,
- mobsController: MobsController
-) : BlocksRenderer(gameWorld, mobsController) {
+ mobsController: MobsController,
+ getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
+ getBlockDamageSprite: GetBlockDamageSpriteUseCase
+) : BlocksRenderer(gameWorld, mobsController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
import ru.deadsoftware.cavedroid.game.model.block.Block
import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.Assets
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
+import ru.fredboy.cavedroid.utils.px
abstract class BlocksRenderer(
protected val gameWorld: GameWorld,
protected val mobsController: MobsController,
+ protected val getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
+ protected val getBlockDamageSprite: GetBlockDamageSpriteUseCase,
) : IGameRenderer {
protected abstract val background: Boolean
get() = isNone() || params.isTransparent
private fun blockDamageSprite(index: Int): Sprite? {
- if (index !in 0..< MAX_BLOCK_DAMAGE_INDEX) {
+ if (index !in 0..< getBlockDamageFrameCount()) {
return null
}
- return Assets.blockDamageSprites[index]
+ return getBlockDamageSprite[index]
}
protected fun drawBlockDamage(spriteBatch: SpriteBatch, viewport: Rectangle) {
import ru.deadsoftware.cavedroid.game.model.block.Block
import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
-import ru.deadsoftware.cavedroid.misc.utils.bl
import ru.deadsoftware.cavedroid.misc.utils.drawString
import ru.deadsoftware.cavedroid.misc.utils.forEachBlockInArea
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.utils.bl
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
private val gameWorld: GameWorld,
private val mobsController: MobsController,
private val debugInfoStringsProvider: DebugInfoStringsProvider,
+ private val getFont: GetFontUseCase,
) : IGameRenderer {
override val renderLayer get() = RENDER_LAYER
private fun drawDebugInfo(spriteBatch: SpriteBatch) {
debugInfoStringsProvider.getDebugStrings().forEachIndexed { index, str ->
- spriteBatch.drawString(str, 0f, index * 10f)
+ spriteBatch.drawString(getFont(), str, 0f, index * 10f)
}
}
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
import ru.deadsoftware.cavedroid.misc.utils.cycledInsideWorld
import ru.deadsoftware.cavedroid.misc.utils.drawSprite
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
import ru.deadsoftware.cavedroid.misc.utils.forEachBlockInArea
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
import javax.inject.Inject
@GameScope
@BindRenderer
class ForegroundBlocksRenderer @Inject constructor(
gameWorld: GameWorld,
- mobsController: MobsController
-) : BlocksRenderer(gameWorld, mobsController) {
+ mobsController: MobsController,
+ getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
+ getBlockDamageSprite: GetBlockDamageSpriteUseCase
+) : BlocksRenderer(gameWorld, mobsController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
import ru.deadsoftware.cavedroid.game.mobs.player.Player.ControlMode
import ru.deadsoftware.cavedroid.game.ui.TooltipManager
import ru.deadsoftware.cavedroid.game.world.GameWorld
-import ru.deadsoftware.cavedroid.misc.Assets
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
import ru.deadsoftware.cavedroid.misc.utils.drawString
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
private val gameWorld: GameWorld,
private val mobsController: MobsController,
private val tooltipManager: TooltipManager,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getStringWidth: GetStringWidthUseCase,
+ private val getStringHeight: GetStringHeightUseCase,
+ private val getFont: GetFontUseCase,
) : IGameRenderer {
override val renderLayer = RENDER_LAYER
- private val cursorTexture get() = requireNotNull(Assets.textureRegions[CURSOR_KEY])
- private val hotbarTexture get() = requireNotNull(Assets.textureRegions[HOTBAR_KEY])
- private val hotbarSelectorTexture get() = requireNotNull(Assets.textureRegions[HOTBAR_SELECTOR_KEY])
- private val wholeHeartTexture get() = requireNotNull(Assets.textureRegions[WHOLE_HEART_KEY])
- private val emptyHeartTexture get() = requireNotNull(Assets.textureRegions[EMPTY_HEART_KEY])
- private val halfHeartTexture get() = requireNotNull(Assets.textureRegions[HALF_HEART_KEY])
+ private val cursorTexture get() = requireNotNull(textureRegions[CURSOR_KEY])
+ private val hotbarTexture get() = requireNotNull(textureRegions[HOTBAR_KEY])
+ private val hotbarSelectorTexture get() = requireNotNull(textureRegions[HOTBAR_SELECTOR_KEY])
+ private val wholeHeartTexture get() = requireNotNull(textureRegions[WHOLE_HEART_KEY])
+ private val emptyHeartTexture get() = requireNotNull(textureRegions[EMPTY_HEART_KEY])
+ private val halfHeartTexture get() = requireNotNull(textureRegions[HALF_HEART_KEY])
private fun drawCursor(spriteBatch: SpriteBatch, viewport: Rectangle) {
val cursorX = mobsController.player.cursorX
item.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
x = hotbarX + HotbarConfig.horizontalMargin +
index * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
y = HotbarConfig.verticalMargin,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
}
}
val tooltip = tooltipManager.currentHotbarTooltip
if (tooltip.isNotBlank()) {
spriteBatch.drawString(
+ font = getFont(),
str = tooltip,
- x = viewport.width / 2 - Assets.getStringWidth(tooltip) / 2,
+ x = viewport.width / 2 - getStringWidth(tooltip) / 2,
y = hotbarTexture.regionHeight.toFloat()
)
}
import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
import ru.deadsoftware.cavedroid.misc.utils.cycledInsideWorld
-import ru.deadsoftware.cavedroid.misc.utils.px
+import ru.fredboy.cavedroid.utils.px
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.render
+import com.badlogic.gdx.graphics.g2d.Sprite
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.misc.utils.ArrayMapExtensions.component1
import ru.deadsoftware.cavedroid.misc.utils.ArrayMapExtensions.component2
import ru.deadsoftware.cavedroid.misc.utils.drawSprite
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTouchButtonsUseCase
import javax.inject.Inject
@GameScope
private val mainConfig: MainConfig,
private val mobsController: MobsController,
private val gameWindowsManager: GameWindowsManager,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getTouchButtons: GetTouchButtonsUseCase,
) : IGameRenderer {
override val renderLayer get() = RENDER_LAYER
- private val shadeTexture get() = Assets.textureRegions[SHADE_KEY]
+ private val shadeTexture get() = textureRegions[SHADE_KEY]
+
+ private val joyBackground = Sprite(textureRegions["joy_background"])
+ private val joyStick = Sprite(textureRegions["joy_stick"])
private fun drawJoystick(spriteBatch: SpriteBatch) {
val joystick = mainConfig.joystick?.takeIf { it.active } ?: return
spriteBatch.drawSprite(
- sprite = Assets.joyBackground,
+ sprite = joyBackground,
x = joystick.centerX - Joystick.RADIUS,
y = joystick.centerY - Joystick.RADIUS,
width = Joystick.SIZE,
)
spriteBatch.drawSprite(
- sprite = Assets.joyStick,
+ sprite = joyStick,
x = joystick.activeX - Joystick.STICK_SIZE / 2,
y = joystick.activeY - Joystick.STICK_SIZE / 2,
width = Joystick.STICK_SIZE,
return
}
- val touchControlsMap = Assets.guiMap
+ val touchControlsMap = getTouchButtons()
touchControlsMap.forEach { (key, value) ->
- val touchKey = value.rect
+ val touchKey = value.rectangle
spriteBatch.draw(
- /* region = */ Assets.textureRegions[key],
+ /* region = */ textureRegions[key],
/* x = */ touchKey.x,
/* y = */ touchKey.y,
/* width = */ touchKey.width,
// FIXME: Add pressed state for buttons
if (mobsController.player.controlMode == ControlMode.CURSOR) {
- val altKeyRect = touchControlsMap.get("alt").rect
+ val altKeyRect = touchControlsMap["alt"]?.rectangle ?: return
spriteBatch.draw(shadeTexture, altKeyRect.x, altKeyRect.y, altKeyRect.width, altKeyRect.height)
}
package ru.deadsoftware.cavedroid.game.render.windows
import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.g2d.BitmapFont
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
import ru.deadsoftware.cavedroid.game.model.item.Item
import ru.deadsoftware.cavedroid.misc.utils.drawSprite
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
abstract class AbstractWindowRenderer {
protected inline fun <reified T> drawItemsGrid(
spriteBatch: SpriteBatch,
shapeRenderer: ShapeRenderer,
+ font: BitmapFont,
gridX: Float,
gridY: Float,
items: Iterable<T>,
itemsInRow: Int,
cellWidth: Float,
- cellHeight: Float
+ cellHeight: Float,
+ getStringWidth: GetStringWidthUseCase,
+ getStringHeight: GetStringHeightUseCase,
) {
if (T::class != Item::class && T::class != InventoryItem::class) {
Gdx.app.log(_TAG, "Trying to draw items grid of not items")
val itemX = gridX + (index % itemsInRow) * cellWidth
val itemY = gridY + (index / itemsInRow) * cellHeight
- inventoryItem?.draw(spriteBatch, shapeRenderer, itemX, itemY)
+ inventoryItem?.draw(spriteBatch, shapeRenderer, font, itemX, itemY, getStringWidth, getStringHeight)
?: item?.let { spriteBatch.drawSprite(it.sprite, itemX, itemY) }
}
}
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.ChestInventoryWindow
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.SurvivalInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
import kotlin.math.atan
@GameScope
class ChestWindowRenderer @Inject constructor(
- private val mainConfig: MainConfig,
private val mobsController: MobsController,
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getStringWidth: GetStringWidthUseCase,
+ private val getStringHeight: GetStringHeightUseCase,
+ private val getFont: GetFontUseCase,
) : AbstractWindowRenderer(), IGameRenderer {
override val renderLayer get() = WindowsRenderer.RENDER_LAYER
- private val chestWindowTexture get() = requireNotNull(Assets.textureRegions[CHEST_WINDOW_KEY])
+ private val chestWindowTexture get() = requireNotNull(textureRegions[CHEST_WINDOW_KEY])
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Chest.contentsMarginLeft,
gridY = windowY + GameWindowsConfigs.Chest.contentsMarginTop,
items = window.chest.items,
itemsInRow = GameWindowsConfigs.Chest.itemsInRow,
cellWidth = GameWindowsConfigs.Chest.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Chest.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Chest.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Chest.itemsGridMarginTop,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Chest.itemsInRow,
cellWidth = GameWindowsConfigs.Chest.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Chest.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Chest.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Chest.hotbarOffsetFromBottom,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Chest.hotbarCells,
cellWidth = GameWindowsConfigs.Chest.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Chest.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
window.selectedItem?.drawSelected(
spriteBatch = spriteBatch,
+ font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
- y = Gdx.input.y * (viewport.height / Gdx.graphics.height)
+ y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
}
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.CraftingInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
class CraftingWindowRenderer @Inject constructor(
- private val mainConfig: MainConfig,
private val mobsController: MobsController,
private val gameWindowsManager: GameWindowsManager,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getStringWidth: GetStringWidthUseCase,
+ private val getStringHeight: GetStringHeightUseCase,
+ private val getFont: GetFontUseCase,
) : AbstractWindowRenderer(), IGameRenderer {
override val renderLayer get() = WindowsRenderer.RENDER_LAYER
- private val craftingWindowTexture get() = requireNotNull(Assets.textureRegions[CRAFTING_WINDOW_KEY])
+ private val craftingWindowTexture get() = requireNotNull(textureRegions[CRAFTING_WINDOW_KEY])
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
val windowTexture = craftingWindowTexture
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Crafting.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Crafting.itemsGridMarginTop,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Crafting.itemsInRow,
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Crafting.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Crafting.hotbarOffsetFromBottom,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Crafting.hotbarCells,
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Crafting.craftOffsetX,
gridY = windowY + GameWindowsConfigs.Crafting.craftOffsetY,
items = window.craftingItems.asSequence().map { it ?: gameItemsHolder.fallbackItem.toInventoryItem()}.asIterable(),
itemsInRow = GameWindowsConfigs.Crafting.craftGridSize,
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
window.craftResult?.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
x = windowX + GameWindowsConfigs.Crafting.craftResultOffsetX,
- y = windowY + GameWindowsConfigs.Crafting.craftResultOffsetY
+ y = windowY + GameWindowsConfigs.Crafting.craftResultOffsetY,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
window.selectedItem?.drawSelected(
spriteBatch = spriteBatch,
+ font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
- y = Gdx.input.y * (viewport.height / Gdx.graphics.height)
+ y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.MainConfig
import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.render.IGameRenderer
import ru.deadsoftware.cavedroid.game.render.WindowsRenderer
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
-import ru.deadsoftware.cavedroid.misc.Assets
+import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
import kotlin.math.min
@GameScope
class CreativeWindowRenderer @Inject constructor(
- private val mainConfig: MainConfig,
private val gameWindowsManager: GameWindowsManager,
private val gameItemsHolder: GameItemsHolder,
private val mobsController: MobsController,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getStringWidth: GetStringWidthUseCase,
+ private val getStringHeight: GetStringHeightUseCase,
+ private val getFont: GetFontUseCase,
) : AbstractWindowRenderer(), IGameRenderer {
override val renderLayer get() = WindowsRenderer.RENDER_LAYER
- private val creativeWindowTexture get() = requireNotNull(Assets.textureRegions[CREATIVE_WINDOW_KEY])
- private val scrollIndicatorTexture get() = requireNotNull(Assets.textureRegions[SCROLL_INDICATOR_KEY])
+ private val creativeWindowTexture get() = requireNotNull(textureRegions[CREATIVE_WINDOW_KEY])
+ private val scrollIndicatorTexture get() = requireNotNull(textureRegions[SCROLL_INDICATOR_KEY])
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Creative.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Creative.itemsGridMarginTop,
items = items.asIterable(),
itemsInRow = GameWindowsConfigs.Creative.itemsInRow,
cellWidth = GameWindowsConfigs.Creative.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Creative.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Creative.itemsGridMarginLeft,
gridY = windowY + creativeWindow.regionHeight - GameWindowsConfigs.Creative.playerInventoryOffsetFromBottom,
items = mobsController.player.inventory.items.asSequence().take(GameWindowsConfigs.Creative.invItems).asIterable(),
itemsInRow = GameWindowsConfigs.Creative.invItems,
cellWidth = GameWindowsConfigs.Creative.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Creative.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
}
package ru.deadsoftware.cavedroid.game.render.windows
import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.g2d.Sprite
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.render.IGameRenderer
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.FurnaceInventoryWindow
-import ru.deadsoftware.cavedroid.misc.Assets
import ru.deadsoftware.cavedroid.misc.utils.drawSprite
import ru.deadsoftware.cavedroid.misc.utils.withScissors
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@GameScope
private val mainConfig: MainConfig,
private val mobsController: MobsController,
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getStringWidth: GetStringWidthUseCase,
+ private val getStringHeight: GetStringHeightUseCase,
+ private val getFont: GetFontUseCase,
) : AbstractWindowRenderer(), IGameRenderer {
override val renderLayer get() = WindowsRenderer.RENDER_LAYER
- private val furnaceWindowTexture get() = requireNotNull(Assets.textureRegions[FURNACE_WINDOW_KEY])
+ private val furnaceWindowTexture get() = requireNotNull(textureRegions[FURNACE_WINDOW_KEY])
+ private val furnaceProgress by lazy { Sprite(textureRegions["furnace_progress"]) }
+ private val furnaceBurn by lazy { Sprite(textureRegions["furnace_burn"]) }
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
val windowTexture = furnaceWindowTexture
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Furnace.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Furnace.itemsGridMarginTop,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Furnace.itemsInRow,
cellWidth = GameWindowsConfigs.Furnace.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Furnace.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Furnace.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Furnace.hotbarOffsetFromBottom,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Furnace.hotbarCells,
cellWidth = GameWindowsConfigs.Furnace.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Furnace.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
window.furnace.fuel?.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
x = windowX + GameWindowsConfigs.Furnace.smeltFuelMarginLeft,
- y = windowY + GameWindowsConfigs.Furnace.smeltFuelMarginTop
+ y = windowY + GameWindowsConfigs.Furnace.smeltFuelMarginTop,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
window.furnace.input?.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
x = windowX + GameWindowsConfigs.Furnace.smeltInputMarginLeft,
- y = windowY + GameWindowsConfigs.Furnace.smeltInputMarginTop
+ y = windowY + GameWindowsConfigs.Furnace.smeltInputMarginTop,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
window.furnace.result?.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
x = windowX + GameWindowsConfigs.Furnace.smeltResultOffsetX,
- y = windowY + GameWindowsConfigs.Furnace.smeltResultOffsetY
+ y = windowY + GameWindowsConfigs.Furnace.smeltResultOffsetY,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
if (window.furnace.isActive) {
mainConfig = mainConfig,
x = windowX + GameWindowsConfigs.Furnace.fuelBurnMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.fuelBurnMarginTop + burn,
- width = Assets.furnaceBurn.width,
+ width = furnaceBurn.width,
height = GameWindowsConfigs.Furnace.fuelBurnHeight,
) {
spriteBatch.drawSprite(
- sprite = Assets.furnaceBurn,
+ sprite = furnaceBurn,
x = windowX + GameWindowsConfigs.Furnace.fuelBurnMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.fuelBurnMarginTop
)
x = windowX + GameWindowsConfigs.Furnace.progressMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.progressMarginTop,
width = progress,
- height = Assets.furnaceProgress.height
+ height = furnaceProgress.height
) {
spriteBatch.drawSprite(
- sprite = Assets.furnaceProgress,
+ sprite = furnaceProgress,
x = windowX + GameWindowsConfigs.Furnace.progressMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.progressMarginTop,
)
window.selectedItem?.drawSelected(
spriteBatch = spriteBatch,
+ font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
- y = Gdx.input.y * (viewport.height / Gdx.graphics.height)
+ y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
}
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.SurvivalInventoryWindow
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
import kotlin.math.atan
private val mobsController: MobsController,
private val gameWindowsManager: GameWindowsManager,
private val gameItemsHolder: GameItemsHolder,
+ private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getStringWidth: GetStringWidthUseCase,
+ private val getStringHeight: GetStringHeightUseCase,
+ private val getFont: GetFontUseCase,
) : AbstractWindowRenderer(), IGameRenderer {
override val renderLayer get() = WindowsRenderer.RENDER_LAYER
- private val survivalWindowTexture get() = requireNotNull(Assets.textureRegions[SURVIVAL_WINDOW_KEY])
+ private val survivalWindowTexture get() = requireNotNull(textureRegions[SURVIVAL_WINDOW_KEY])
private fun setPortraitHeadRotation(portraitX: Float, portraitY: Float) {
if (mainConfig.isTouch) {
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Survival.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Survival.itemsGridMarginTop,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Survival.itemsInRow,
cellWidth = GameWindowsConfigs.Survival.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Survival.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Survival.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Survival.hotbarOffsetFromBottom,
items = mobsController.player.inventory.items.asSequence()
itemsInRow = GameWindowsConfigs.Survival.hotbarCells,
cellWidth = GameWindowsConfigs.Survival.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Survival.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
gridX = windowX + GameWindowsConfigs.Survival.craftOffsetX,
gridY = windowY + GameWindowsConfigs.Survival.craftOffsetY,
items = window.craftingItems.asSequence().mapIndexedNotNull { index, it ->
itemsInRow = GameWindowsConfigs.Survival.craftGridSize,
cellWidth = GameWindowsConfigs.Survival.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Survival.itemsGridRowHeight,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight
)
window.craftResult?.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
+ font = getFont(),
x = windowX + GameWindowsConfigs.Survival.craftResultOffsetX,
- y = windowY + GameWindowsConfigs.Survival.craftResultOffsetY
+ y = windowY + GameWindowsConfigs.Survival.craftResultOffsetY,
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
window.selectedItem?.drawSelected(
spriteBatch = spriteBatch,
+ font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
- y = Gdx.input.y * (viewport.height / Gdx.graphics.height)
+ y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
+ getStringWidth = getStringWidth,
+ getStringHeight = getStringHeight,
)
}
import ru.deadsoftware.cavedroid.game.objects.drop.DropController
import ru.deadsoftware.cavedroid.game.ui.TooltipManager
import ru.deadsoftware.cavedroid.game.world.GameWorld
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPlayerSpritesUseCase
import java.nio.ByteBuffer
import java.util.zip.GZIPInputStream
import java.util.zip.GZIPOutputStream
fun load(
mainConfig: MainConfig,
gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager
+ tooltipManager: TooltipManager,
+ getPlayerSprites: GetPlayerSpritesUseCase,
+ getPigSprites: GetPigSpritesUseCase,
): GameSaveData {
val gameFolder = mainConfig.gameFolder
val savesPath = "$gameFolder$SAVES_DIR"
val containersBytes = containersFile.readBytes()
val dropController = ProtoBuf.decodeFromByteArray<SaveDataDto.DropControllerSaveData>(dropBytes)
- .let { saveData -> DropController.fromSaveData(saveData, gameItemsHolder) }
+ .let { saveData ->
+ DropController.fromSaveData(
+ /* saveData = */ saveData,
+ /* gameItemsHolder = */ gameItemsHolder
+ )
+ }
+
val mobsController = ProtoBuf.decodeFromByteArray<SaveDataDto.MobsControllerSaveData>(mobsBytes)
- .let { saveData -> MobsController.fromSaveData(saveData, gameItemsHolder, tooltipManager) }
+ .let { saveData ->
+ MobsController.fromSaveData(
+ saveData = saveData,
+ gameItemsHolder = gameItemsHolder,
+ tooltipManager = tooltipManager,
+ getPigSprites = getPigSprites,
+ getPlayerSprites = getPlayerSprites
+ )
+ }
+
val containerController = ProtoBuf.decodeFromByteArray<SaveDataDto.ContainerControllerSaveData>(containersBytes)
- .let { saveData -> ContainerController.fromSaveData(saveData, dropController, gameItemsHolder) }
+ .let { saveData ->
+ ContainerController.fromSaveData(
+ saveData = saveData,
+ dropController = dropController,
+ gameItemsHolder = gameItemsHolder
+ )
+ }
val (foreMap, backMap) = loadMap(gameItemsHolder, savesPath)
import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.misc.utils.bl
+import ru.fredboy.cavedroid.utils.bl
import java.util.PriorityQueue
import javax.inject.Inject
import kotlin.math.min
import ru.deadsoftware.cavedroid.menu.objects.ButtonEventListener
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
class MenuOptions(
width: Float,
mainConfig: MainConfig,
menuInput: MenuProc.Input,
assetLoader: AssetLoader,
-) : Menu(width, height, buttonRenderer, mainConfig, menuInput, assetLoader) {
+ getTextureRegionByName: GetTextureRegionByNameUseCase,
+) : Menu(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName) {
override fun getButtonEventListeners(): HashMap<String, ButtonEventListener> {
val map = HashMap<String, ButtonEventListener>()
import ru.deadsoftware.cavedroid.menu.MenuScope
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
+import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import javax.inject.Inject
@MenuScope
class MenusFactory @Inject constructor(
private val mainConfig: MainConfig,
private val assetLoader: AssetLoader,
+ private val getTextureRegionByName: GetTextureRegionByNameUseCase,
) {
fun getMainMenu(
buttonRenderer: ButtonRenderer,
menuInput: MenuProc.Input,
): MenuMain {
- return MenuMain(width, height, buttonRenderer, mainConfig, menuInput, assetLoader)
+ return MenuMain(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName)
}
fun getMenuNewGame(
buttonRenderer: ButtonRenderer,
menuInput: MenuProc.Input,
): MenuNewGame {
- return MenuNewGame(width, height, buttonRenderer, mainConfig, menuInput, assetLoader)
+ return MenuNewGame(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName)
}
fun getMenuOptions(
buttonRenderer: ButtonRenderer,
menuInput: MenuProc.Input,
): MenuOptions {
- return MenuOptions(width, height, buttonRenderer, mainConfig, menuInput, assetLoader)
+ return MenuOptions(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName)
}
}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.misc.utils
-
-import com.badlogic.gdx.math.MathUtils
-
-/**
- * Converts this value in BLOCKS into pixels
- */
-val Float.px get() = this * 16f
-
-/**
- * Converts this value in BLOCKS into pixels
- */
-val Int.px get() = this * 16f
-
-/**
- * Converts this value in PIXELS into blocks
- */
-val Float.bl get() = MathUtils.floor(this / 16f)
\ No newline at end of file
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.GL20
+import com.badlogic.gdx.graphics.g2d.BitmapFont
import com.badlogic.gdx.graphics.g2d.GlyphLayout
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.MainConfig
import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.utils.bl
private fun Rectangle.shifted(shift: Float) = Rectangle(x + shift, y, width, height)
}
@JvmOverloads
-fun SpriteBatch.drawString(str: String, x: Float, y: Float, color: Color = Color.WHITE): GlyphLayout {
- Assets.minecraftFont.color = color
- return Assets.minecraftFont.draw(this, str, x, y)
+fun SpriteBatch.drawString(
+ font: BitmapFont,
+ str: String,
+ x: Float,
+ y: Float,
+ color: Color = Color.WHITE
+): GlyphLayout {
+ font.color = color
+ return font.draw(this, str, x, y)
}
/**
+++ /dev/null
-package ru.deadsoftware.cavedroid.misc.utils.mobs
-
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.Mob.Direction
-import ru.deadsoftware.cavedroid.misc.Assets
-
-object MobSprites {
-
- object Player {
-
- fun getBackgroundHand() = Assets.playerSprite[1][2]
-
- fun getForegroundHand() = Assets.playerSprite[0][2]
-
- fun getBackgroundLeg() = Assets.playerSprite[1][3]
-
- fun getForegroundLeg() = Assets.playerSprite[0][3]
-
- fun getHead(direction: Mob.Direction) = Assets.playerSprite[direction.index][0]
-
- fun getBody(direction: Direction) = Assets.playerSprite[direction.index][1]
-
- fun getBodyRelativeX() = 2
-
- fun getBodyRelativeY() = 8
-
- fun getLegsRelativeY() = 20
-
- }
-
- object Pig {
-
- fun getForegroundLeg() = Assets.pigSprite[0][1]
-
- fun getBackgroundLeg() = Assets.pigSprite[1][1]
-
- fun getBody(direction: Direction) = Assets.pigSprite[direction.index][0]
-
- fun getLeftLegRelativeX(direction: Direction) = 9 - direction.index * 9
-
- fun getRightLegRelativeX(direction: Direction) = 21 - (9 * direction.index)
-
- fun getLegsRelativeY() = 12
-
- }
-
-}
\ No newline at end of file
include("android")
include("desktop")
include("core")
+
+include("core:base")
+
+// data modules
+include("core:data:assets")
+
+//domain modules
+include("core:domain:assets")
