add("implementation", project(moduleName))
}
-fun DependencyHandler.useBaseModule() {
- useModule(":core:base")
+fun DependencyHandler.useCommonModule() {
+ useModule(":core:common")
}
fun DependencyHandler.useAutomultibind() {
useKotlinxSerializationJson()
useKotlinxSerializationProtobuf()
- useBaseModule()
+ useCommonModule()
// data
useModule(":core:data:assets")
+ useModule(":core:data:items")
+ useModule(":core:data:save")
- //domain
+ // domain
useModule(":core:domain:assets")
+ useModule(":core:domain:items")
+ useModule(":core:domain:save")
+
+ // controller
+ useModule(":core:game:controller:drop")
+ useModule(":core:game:controller:container")
+ useModule(":core:game:controller:mob")
+
+ // world
+ useModule(":core:game:world")
implementation(Dependencies.jetbrainsAnnotations)
-}
\ No newline at end of file
+}
-package ru.deadsoftware.cavedroid.game
+package ru.fredboy.cavedroid.common.di
import javax.inject.Scope
-package ru.deadsoftware.cavedroid.misc.utils
+package ru.fredboy.cavedroid.common.model
import com.badlogic.gdx.graphics.g2d.Sprite
--- /dev/null
+package ru.fredboy.cavedroid.common.utils
+
+import com.badlogic.gdx.Graphics
+
+val Graphics.ratio get() = width.toFloat() / height.toFloat()
-package ru.fredboy.cavedroid.utils
+package ru.fredboy.cavedroid.common.utils
import com.badlogic.gdx.math.MathUtils
-package ru.deadsoftware.cavedroid.misc.utils
+package ru.fredboy.cavedroid.common.utils
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.graphics.Color
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)
}
fun SpriteBatch.withScissors(
- mainConfig: MainConfig,
+ viewportWidth: Float,
+ viewportHeight: Float,
x: Float,
y: Float,
width: Float,
height: Float,
block: () -> Unit
) {
- val scaleX = Gdx.graphics.width / mainConfig.width
- val scaleY = Gdx.graphics.height / mainConfig.height
+ val scaleX = Gdx.graphics.width / viewportWidth
+ val scaleY = Gdx.graphics.height / viewportHeight
flush()
Gdx.gl.glEnable(GL20.GL_SCISSOR_TEST)
Gdx.gl.glScissor(
/* x = */ (x * scaleX).toInt(),
- /* y = */ ((mainConfig.height - y - height) * scaleY).toInt(),
+ /* y = */ ((viewportHeight - y - height) * scaleY).toInt(),
/* width = */ (width * scaleX).toInt(),
/* height = */ (height * scaleY).toInt()
)
-package ru.deadsoftware.cavedroid.misc.utils
+package ru.fredboy.cavedroid.common.utils
import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.g2d.Sprite
import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import ru.fredboy.cavedroid.common.model.SpriteOrigin
/**
* Draw sprite at given position rotated by [rotation] degrees
fun Sprite.applyOrigin(origin: SpriteOrigin) {
origin.applyToSprite(this)
-}
\ No newline at end of file
+}
java.targetCompatibility = ApplicationInfo.sourceCompatibility
dependencies {
- useBaseModule()
+ useCommonModule()
useModule(":core:domain:assets")
useLibgdx()
useKotlinxSerializationJson()
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 ru.fredboy.cavedroid.common.utils.BLOCK_SIZE_PX
+import ru.fredboy.cavedroid.common.utils.bl
+import ru.fredboy.cavedroid.common.utils.px
import javax.inject.Inject
import javax.inject.Singleton
--- /dev/null
+plugins {
+ kotlin
+ ksp
+ kotlinxSerialization
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useCommonModule()
+ useLibgdx()
+ useKotlinxSerializationJson()
+ useDagger()
+
+ useModule(":core:domain:assets")
+ useModule(":core:domain:items")
+}
--- /dev/null
+package ru.fredboy.cavedroid.data.items.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.data.items.repository.ItemsRepositoryImpl
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+
+@Module
+abstract class DataItemsModule {
+
+ @Binds
+ internal abstract fun bindItemsRepository(impl: ItemsRepositoryImpl): ItemsRepository
+
+}
-package ru.deadsoftware.cavedroid.game.model.mapper
+package ru.fredboy.cavedroid.data.items.mapper
import com.badlogic.gdx.graphics.Texture
-import dagger.Reusable
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.model.block.*
-import ru.deadsoftware.cavedroid.game.model.block.Block.*
-import ru.deadsoftware.cavedroid.game.model.dto.BlockDto
-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.data.items.model.BlockDto
+import ru.fredboy.cavedroid.data.items.repository.ItemsRepositoryImpl
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockTextureUseCase
+import ru.fredboy.cavedroid.domain.items.model.block.*
+import ru.fredboy.cavedroid.domain.items.model.block.Block.*
+import ru.fredboy.cavedroid.domain.items.model.item.Item
import javax.inject.Inject
+import javax.inject.Singleton
-@Reusable
+@Singleton
class BlockMapper @Inject constructor(
- private val assetLoader: AssetLoader,
private val getBlockTexture: GetBlockTextureUseCase,
) {
val drop = dto.drop
val dropCount = dto.dropCount
- if (drop == GameItemsHolder.FALLBACK_ITEM_KEY || dropCount == 0) {
+ if (drop == ItemsRepositoryImpl.FALLBACK_ITEM_KEY || dropCount == 0) {
return null
}
}
private fun getTexture(textureName: String): Texture? {
- if (textureName == GameItemsHolder.FALLBACK_BLOCK_KEY) {
+ if (textureName == ItemsRepositoryImpl.FALLBACK_BLOCK_KEY) {
return null
}
--- /dev/null
+package ru.fredboy.cavedroid.data.items.mapper
+
+import com.badlogic.gdx.graphics.g2d.Sprite
+import ru.fredboy.cavedroid.common.model.SpriteOrigin
+import ru.fredboy.cavedroid.common.utils.colorFromHexString
+import ru.fredboy.cavedroid.data.items.model.ItemDto
+import ru.fredboy.cavedroid.data.items.repository.ItemsRepositoryImpl
+import ru.fredboy.cavedroid.domain.assets.usecase.GetItemTextureUseCase
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.item.CommonItemParams
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.model.item.Item.*
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class ItemMapper @Inject constructor(
+ private val getItemTexture: GetItemTextureUseCase,
+) {
+
+ fun map(key: String, dto: ItemDto, block: Block?, slabTopBlock: Block.Slab?, slabBottomBlock: Block.Slab?): Item {
+ val params = mapCommonParams(key, dto)
+
+ return when (dto.type) {
+ "normal" -> Normal(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto))
+ )
+
+ "usable" -> Usable(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ useActionKey = requireNotNull(dto.actionKey)
+ )
+
+ "shovel" -> Shovel(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ mobDamageMultiplier = dto.mobDamageMultiplier,
+ blockDamageMultiplier = dto.blockDamageMultiplier,
+ level = requireNotNull(dto.toolLevel)
+ )
+
+ "sword" -> Sword(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ mobDamageMultiplier = dto.mobDamageMultiplier,
+ blockDamageMultiplier = dto.blockDamageMultiplier,
+ level = requireNotNull(dto.toolLevel)
+ )
+
+ "pickaxe" -> Pickaxe(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ mobDamageMultiplier = dto.mobDamageMultiplier,
+ blockDamageMultiplier = dto.blockDamageMultiplier,
+ level = requireNotNull(dto.toolLevel)
+ )
+
+ "axe" -> Axe(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ mobDamageMultiplier = dto.mobDamageMultiplier,
+ blockDamageMultiplier = dto.blockDamageMultiplier,
+ level = requireNotNull(dto.toolLevel)
+ )
+
+ "shears" -> Shears(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ mobDamageMultiplier = dto.mobDamageMultiplier,
+ blockDamageMultiplier = dto.blockDamageMultiplier,
+ level = requireNotNull(dto.toolLevel)
+ )
+
+ "block" -> Block(
+ params = params,
+ block = requireNotNull(block)
+ )
+
+ "slab" -> Slab(
+ params = params,
+ topPartBlock = requireNotNull(slabTopBlock),
+ bottomPartBlock = requireNotNull(slabBottomBlock)
+ )
+
+ "food" -> Food(
+ params = params,
+ sprite = requireNotNull(loadSprite(dto)),
+ heal = requireNotNull(dto.heal)
+ )
+
+ "none" -> None(
+ params = params
+ )
+
+ else -> throw IllegalArgumentException("Unknown item type ${dto.type}")
+ }
+ }
+
+ private fun mapCommonParams(key: String, dto: ItemDto): CommonItemParams {
+ return CommonItemParams(
+ key = key,
+ name = dto.name,
+ inHandSpriteOrigin = SpriteOrigin(
+ x = dto.originX,
+ y = dto.origin_y,
+ ),
+ maxStack = dto.maxStack,
+ burningTimeMs = dto.burningTime,
+ smeltProductKey = dto.smeltProduct,
+ )
+ }
+
+ private fun loadSprite(dto: ItemDto): Sprite? {
+ if (dto.type == "none" || dto.type == "block" || dto.texture == ItemsRepositoryImpl.FALLBACK_ITEM_KEY) {
+ return null
+ }
+
+ val texture = getItemTexture[dto.texture]
+ return Sprite(texture)
+ .apply {
+ flip(false, true)
+ dto.tint?.let {
+ color = colorFromHexString(it)
+ }
+ }
+ }
+
+}
\ No newline at end of file
-package ru.deadsoftware.cavedroid.game.model.dto
+package ru.fredboy.cavedroid.data.items.model
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
-package ru.deadsoftware.cavedroid.game.model.dto
+package ru.fredboy.cavedroid.data.items.model
import kotlinx.serialization.Serializable
-package ru.deadsoftware.cavedroid.game.model.dto
+package ru.fredboy.cavedroid.data.items.model
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.*
@Serializable
data class GameItemsDto(
-package ru.deadsoftware.cavedroid.game.model.dto
+package ru.fredboy.cavedroid.data.items.model
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
-package ru.deadsoftware.cavedroid.game
+package ru.fredboy.cavedroid.data.items.repository
import com.badlogic.gdx.Gdx
import kotlinx.serialization.json.Json
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.model.craft.CraftingRecipe
-import ru.deadsoftware.cavedroid.game.model.craft.CraftingResult
-import ru.deadsoftware.cavedroid.game.model.dto.BlockDto
-import ru.deadsoftware.cavedroid.game.model.dto.CraftingDto
-import ru.deadsoftware.cavedroid.game.model.dto.GameItemsDto
-import ru.deadsoftware.cavedroid.game.model.dto.ItemDto
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.model.mapper.BlockMapper
-import ru.deadsoftware.cavedroid.game.model.mapper.ItemMapper
-import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
-import java.util.LinkedList
+import ru.fredboy.cavedroid.data.items.mapper.BlockMapper
+import ru.fredboy.cavedroid.data.items.mapper.ItemMapper
+import ru.fredboy.cavedroid.data.items.model.BlockDto
+import ru.fredboy.cavedroid.data.items.model.CraftingDto
+import ru.fredboy.cavedroid.data.items.model.GameItemsDto
+import ru.fredboy.cavedroid.data.items.model.ItemDto
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.craft.CraftingRecipe
+import ru.fredboy.cavedroid.domain.items.model.craft.CraftingResult
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import java.util.*
import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.collections.LinkedHashMap
-@GameScope
-class GameItemsHolder @Inject constructor(
- private val assetLoader: AssetLoader,
- private val blockMapper: BlockMapper,
+@Singleton
+internal class ItemsRepositoryImpl @Inject constructor(
private val itemMapper: ItemMapper,
-) {
+ private val blockMapper: BlockMapper,
+) : ItemsRepository {
private var _initialized: Boolean = false
private val itemsMap = LinkedHashMap<String, Item>()
private val craftingRecipes = LinkedList<CraftingRecipe>()
- lateinit var fallbackBlock: Block
+ override lateinit var fallbackBlock: Block.None
private set
- lateinit var fallbackItem: Item
+
+ override lateinit var fallbackItem: Item.None
private set
init {
.apply(Block::initialize)
}
- fallbackBlock = blocksMap[FALLBACK_BLOCK_KEY]
+ fallbackBlock = blocksMap[FALLBACK_BLOCK_KEY] as? Block.None
?: throw IllegalArgumentException("Fallback block key '$FALLBACK_BLOCK_KEY' not found")
}
}
}
- fallbackItem = itemsMap[FALLBACK_ITEM_KEY]
+ fallbackItem = itemsMap[FALLBACK_ITEM_KEY] as? Item.None
?: throw IllegalArgumentException("Fallback item key '$FALLBACK_ITEM_KEY' not found")
}
private fun loadCraftingRecipes() {
- val jsonString = assetLoader.getAssetHandle("json/crafting.json").readString()
+ val jsonString = Gdx.files.internal("json/crafting.json").readString()
val jsonMap = JsonFormat.decodeFromString<Map<String, CraftingDto>>(jsonString)
if (jsonMap.isNotEmpty() && itemsMap.isEmpty()) {
jsonMap.forEach { (key, value) ->
craftingRecipes += CraftingRecipe(
input = value.input.map(::Regex),
- output = CraftingResult(getItem(key), value.count)
+ output = CraftingResult(getItemByKey(key), value.count)
)
}
}
- fun initialize() {
+ private fun <T> Map<String, T>.getOrFallback(key: String, fallback: T, lazyErrorMessage: () -> String): T {
+ if (!_initialized) {
+ throw IllegalStateException("GameItemsHolder was not initialized before use")
+ }
+
+ val t = this[key] ?: run {
+ Gdx.app.error(TAG, lazyErrorMessage.invoke())
+ return fallback
+ }
+ return t
+ }
+
+ override fun initialize() {
if (_initialized) {
Gdx.app.debug(TAG, "Attempted to init when already initialized")
return
}
- val jsonString = assetLoader.getAssetHandle("json/game_items.json").readString()
+ val jsonString = Gdx.files.internal("json/game_items.json").readString()
val gameItemsDto = JsonFormat.decodeFromString<GameItemsDto>(jsonString)
loadBlocks(gameItemsDto.blocks)
loadCraftingRecipes()
}
- private fun <T> Map<String, T>.getOrFallback(key: String, fallback: T, lazyErrorMessage: () -> String): T {
- if (!_initialized) {
- throw IllegalStateException("GameItemsHolder was not initialized before use")
+ override fun getItemByKey(key: String): Item {
+ return itemsMap.getOrFallback(key, fallbackItem) {
+ "No item with key '$key' found. Returning $FALLBACK_ITEM_KEY"
}
+ }
- val t = this[key] ?: run {
- Gdx.app.error(TAG, lazyErrorMessage.invoke())
- return fallback
+ override fun getItemByIndex(index: Int): Item {
+ return if (index in itemsMap.values.indices) {
+ itemsMap.values.elementAt(index)
+ } else {
+ fallbackItem
}
- return t
}
- fun getBlock(key: String): Block {
+ override fun getBlockByKey(key: String): Block {
return blocksMap.getOrFallback(key, fallbackBlock) {
"No block with key '$key' found. Returning $FALLBACK_BLOCK_KEY"
}
}
- fun getItem(key: String): Item {
- return itemsMap.getOrFallback(key, fallbackItem) {
- "No item with key '$key' found. Returning $FALLBACK_BLOCK_KEY"
- }
+ override fun <T : Block> getBlocksByType(type: Class<T>): List<T> {
+ return blocksMap.values.filterIsInstance(type)
}
- fun craftItem(input: List<Item>): InventoryItem? {
- val startIndex = input.indexOfFirst { !it.isNone() }.takeIf { it >= 0 } ?: return null
-
- return try {
- craftingRecipes.first { rec ->
- for (i in rec.input.indices) {
- if (startIndex + i >= input.size) {
- return@first rec.input.subList(i, rec.input.size).all { it.matches("none") }
- }
- if (!input[startIndex + i].params.key.matches(rec.input[i])) {
- return@first false
- }
+ override fun getCraftingResult(input: List<Item>): InventoryItem {
+ val startIndex = input.indexOfFirst { !it.isNone() }.takeIf { it >= 0 }
+ ?: return fallbackItem.toInventoryItem()
+
+ val output = craftingRecipes.firstOrNull { rec ->
+ for (i in rec.input.indices) {
+ if (startIndex + i >= input.size) {
+ return@firstOrNull rec.input.subList(i, rec.input.size).all { it.matches("none") }
}
- return@first true
- }.output.toInventoryItem()
- } catch (e: NoSuchElementException) {
- null
- }
- }
+ if (!input[startIndex + i].params.key.matches(rec.input[i])) {
+ return@firstOrNull false
+ }
+ }
+ return@firstOrNull true
+ }?.output
- fun getAllItems(): Collection<Item> {
- return itemsMap.values
+ return output?.toInventoryItem() ?: fallbackItem.toInventoryItem()
}
- fun getItemFromCreativeInventory(position: Int): Item {
- return if (position in itemsMap.values.indices) {
- itemsMap.values.elementAt(position)
- } else {
- fallbackItem
- }
+ override fun getAllItems(): Collection<Item> {
+ return itemsMap.values
}
- fun getMaxCreativeScrollAmount(): Int = itemsMap.size / 8
+ override fun dispose() {
+ _initialized = false
- fun <T : Block> getBlocksByType(type: Class<T>): List<T> {
- return blocksMap.values.filterIsInstance(type)
+ blocksMap.clear()
+ itemsMap.clear()
+ craftingRecipes.clear()
}
companion object {
- private const val TAG = "GameItemsHolder"
+ private const val TAG = "ItemsRepositoryImpl"
private val JsonFormat = Json { ignoreUnknownKeys = true }
const val FALLBACK_BLOCK_KEY = "none"
const val FALLBACK_ITEM_KEY = "none"
}
+
}
\ No newline at end of file
--- /dev/null
+plugins {
+ kotlin
+ ksp
+ kotlinxSerialization
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useCommonModule()
+ useLibgdx()
+ useKotlinxSerializationProtobuf()
+ useDagger()
+
+ useModule(":core:domain:assets")
+ useModule(":core:domain:items")
+ useModule(":core:domain:save")
+
+ useModule(":core:game:controller:container")
+ useModule(":core:game:controller:drop")
+ useModule(":core:game:controller:mob")
+ useModule(":core:game:world")
+}
--- /dev/null
+package ru.fredboy.cavedroid.data.save.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.data.save.repository.SaveDataRepositoryImpl
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
+
+@Module
+abstract class DataSaveModule {
+
+ @Binds
+ internal abstract fun bindSaveDataRepository(impl: SaveDataRepositoryImpl): SaveDataRepository
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.game.controller.container.model.Chest
+import javax.inject.Inject
+
+@Reusable
+class ChestMapper @Inject constructor(
+ private val inventoryItemMapper: InventoryItemMapper,
+ private val getFallbackItemUseCase: GetFallbackItemUseCase,
+) {
+
+ fun mapSaveData(chest: Chest): SaveDataDto.ChestSaveDataDto {
+ return SaveDataDto.ChestSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ size = chest.size,
+ items = chest.items.map(inventoryItemMapper::mapSaveData)
+ )
+ }
+
+ fun mapChest(saveDataDto: SaveDataDto.ChestSaveDataDto): Chest {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return Chest(
+ fallbackItem = getFallbackItemUseCase(),
+ initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem)
+ )
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.container.impl.ContainerControllerImpl
+import ru.fredboy.cavedroid.game.controller.container.model.Chest
+import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import javax.inject.Inject
+
+@Reusable
+class ContainerControllerMapper @Inject constructor(
+ private val chestMapper: ChestMapper,
+ private val furnaceMapper: FurnaceMapper,
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
+) {
+
+ fun mapSaveData(containerController: ContainerControllerImpl): SaveDataDto.ContainerControllerSaveDataDto {
+ return SaveDataDto.ContainerControllerSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ containerMap = containerController.containerMap.mapNotNull { (key, container) ->
+ when (container) {
+ is Furnace -> furnaceMapper.mapSaveData(container)
+ is Chest -> chestMapper.mapSaveData(container)
+ else -> null
+ }?.let { value -> key to value }
+ }.toMap()
+ )
+ }
+
+ fun mapContainerController(saveDataDto: SaveDataDto.ContainerControllerSaveDataDto): ContainerControllerImpl {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return ContainerControllerImpl(getItemByKeyUseCase).apply {
+ saveDataDto.containerMap.forEach { (key, value) ->
+ val container = when (value) {
+ is SaveDataDto.FurnaceSaveDataDto -> furnaceMapper.mapFurnace(value)
+ is SaveDataDto.ChestSaveDataDto -> chestMapper.mapChest(value)
+ else -> null
+ }
+
+ if (container != null) {
+ containerMap.put(key, container)
+ }
+ }
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import com.badlogic.gdx.Gdx
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import javax.inject.Inject
+
+@Reusable
+class ControlModeMapper @Inject constructor() {
+
+ fun mapSaveData(direction: Player.ControlMode): SaveDataDto.ControlModeSaveDataDto {
+ return SaveDataDto.ControlModeSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ value = when (direction) {
+ Player.ControlMode.WALK -> 0
+ Player.ControlMode.CURSOR -> 1
+ }
+ )
+ }
+
+ fun mapControlMode(saveDataDto: SaveDataDto.ControlModeSaveDataDto): Player.ControlMode {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return when (saveDataDto.value) {
+ 0 -> Player.ControlMode.WALK
+ 1 -> Player.ControlMode.CURSOR
+ else -> {
+ Gdx.app.error(TAG, "Unknown control mode value: ${saveDataDto.value}")
+ Player.ControlMode.CURSOR
+ }
+ }
+ }
+
+ companion object {
+ private const val TAG = "ControlModeMapper"
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import com.badlogic.gdx.Gdx
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.game.controller.mob.model.Direction
+import javax.inject.Inject
+
+@Reusable
+class DirectionMapper @Inject constructor() {
+
+ fun mapSaveData(direction: Direction): SaveDataDto.DirectionSaveDataDto {
+ return SaveDataDto.DirectionSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ value = when (direction) {
+ Direction.LEFT -> 0
+ Direction.RIGHT -> 1
+ }
+ )
+ }
+
+ fun mapDirection(saveDataDto: SaveDataDto.DirectionSaveDataDto): Direction {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return when (saveDataDto.value) {
+ 0 -> Direction.LEFT
+ 1 -> Direction.RIGHT
+ else -> {
+ Gdx.app.error(TAG, "Unknown direction value: ${saveDataDto.value}")
+ Direction.RIGHT
+ }
+ }
+ }
+
+ companion object {
+ private const val TAG = "DirectionMapper"
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.impl.DropControllerImpl
+import javax.inject.Inject
+
+@Reusable
+class DropControllerMapper @Inject constructor(
+ private val dropMapper: DropMapper
+) {
+
+ fun mapSaveData(dropController: DropController): SaveDataDto.DropControllerSaveDataDto {
+ return SaveDataDto.DropControllerSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ drops = dropController.getAllDrop().map(dropMapper::mapSaveData)
+ )
+ }
+
+ fun mapDropController(saveDataDto: SaveDataDto.DropControllerSaveDataDto): DropController {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return DropControllerImpl(
+ initialDrop = saveDataDto.drops.map(dropMapper::mapDrop)
+ )
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import javax.inject.Inject
+
+@Reusable
+class DropMapper @Inject constructor(
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
+) {
+
+ fun mapSaveData(drop: Drop): SaveDataDto.DropSaveDataDto {
+ return SaveDataDto.DropSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ x = drop.x,
+ y = drop.y,
+ width = drop.width,
+ height = drop.height,
+ velocityX = drop.velocity.x,
+ velocityY = drop.velocity.y,
+ itemKey = drop.item.params.key,
+ amount = drop.amount,
+ pickedUp = drop.isPickedUp
+ )
+ }
+
+ fun mapDrop(saveDataDto: SaveDataDto.DropSaveDataDto): Drop {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return Drop(
+ x = saveDataDto.x,
+ y = saveDataDto.y,
+ item = getItemByKeyUseCase[saveDataDto.itemKey],
+ _amount = saveDataDto.amount
+ ).apply {
+ width = saveDataDto.width
+ height = saveDataDto.height
+ velocity.y = saveDataDto.velocityY
+ velocity.x = saveDataDto.velocityX
+ isPickedUp = saveDataDto.pickedUp
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.mob.model.FallingBlock
+import javax.inject.Inject
+
+@Reusable
+class FallingBlockMapper @Inject constructor(
+ private val directionMapper: DirectionMapper,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
+) {
+
+ fun mapSaveData(fallingBlock: FallingBlock): SaveDataDto.FallingBlockSaveDataDto {
+ return SaveDataDto.FallingBlockSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ x = fallingBlock.x,
+ y = fallingBlock.y,
+ width = fallingBlock.width,
+ height = fallingBlock.height,
+ velocityX = fallingBlock.velocity.x,
+ velocityY = fallingBlock.velocity.y,
+ animDelta = fallingBlock.animDelta,
+ anim = fallingBlock.anim,
+ direction = directionMapper.mapSaveData(fallingBlock.direction),
+ dead = fallingBlock.isDead,
+ canJump = fallingBlock.canJump,
+ flyMode = fallingBlock.isFlyMode,
+ maxHealth = fallingBlock.maxHealth,
+ health = fallingBlock.health,
+ blockKey = fallingBlock.block.params.key,
+ )
+ }
+
+ fun mapFallingBlock(saveDataDto: SaveDataDto.FallingBlockSaveDataDto): FallingBlock {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return FallingBlock(
+ block = getBlockByKeyUseCase[saveDataDto.blockKey],
+ x = saveDataDto.x,
+ y = saveDataDto.y
+ ).apply {
+ width = saveDataDto.width
+ height = saveDataDto.height
+ velocity.x = saveDataDto.velocityX
+ velocity.x = saveDataDto.velocityY
+ animDelta = saveDataDto.animDelta
+ anim = saveDataDto.anim
+ direction = directionMapper.mapDirection(saveDataDto.direction)
+ canJump = saveDataDto.canJump
+ isFlyMode = saveDataDto.flyMode
+ health = saveDataDto.health
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import javax.inject.Inject
+
+@Reusable
+class FurnaceMapper @Inject constructor(
+ private val inventoryItemMapper: InventoryItemMapper,
+ private val getFallbackItem: GetFallbackItemUseCase,
+ private val getItemByKey: GetItemByKeyUseCase,
+) {
+
+ fun mapSaveData(furnace: Furnace): SaveDataDto.FurnaceSaveDataDto {
+ return SaveDataDto.FurnaceSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ size = furnace.size,
+ currentFuelItemKey = furnace.currentFuelKey,
+ items = furnace.items.map(inventoryItemMapper::mapSaveData),
+ startBurnTimeMs = furnace.startBurnTimeMs,
+ startSmeltTimeMs = furnace.smeltStarTimeMs,
+ burnProgress = furnace.burnProgress,
+ smeltProgress = furnace.smeltProgress,
+ )
+ }
+
+ fun mapFurnace(saveDataDto: SaveDataDto.FurnaceSaveDataDto): Furnace {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return Furnace(
+ fallbackItem = getFallbackItem(),
+ initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem),
+ ).apply {
+ currentFuel = saveDataDto.currentFuelItemKey?.let(getItemByKey::get) ?: getFallbackItem()
+ startBurnTimeMs = saveDataDto.startBurnTimeMs
+ smeltStarTimeMs = saveDataDto.startSmeltTimeMs
+ burnProgress = saveDataDto.burnProgress
+ smeltProgress = saveDataDto.smeltProgress
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import javax.inject.Inject
+
+@Reusable
+class InventoryItemMapper @Inject constructor(
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
+) {
+
+ fun mapSaveData(inventoryItem: InventoryItem): SaveDataDto.InventoryItemSaveDataDto {
+ return SaveDataDto.InventoryItemSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ itemKey = inventoryItem.item.params.key,
+ amount = inventoryItem.amount
+ )
+ }
+
+ fun mapInventoryItem(saveDataDto: SaveDataDto.InventoryItemSaveDataDto): InventoryItem {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return InventoryItem(
+ item = getItemByKeyUseCase[saveDataDto.itemKey],
+ _amount = saveDataDto.amount,
+ )
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.game.controller.mob.model.Inventory
+import javax.inject.Inject
+
+@Reusable
+class InventoryMapper @Inject constructor(
+ private val inventoryItemMapper: InventoryItemMapper,
+ private val getFallbackItem: GetFallbackItemUseCase,
+) {
+
+ fun mapSaveData(inventory: Inventory): SaveDataDto.InventorySaveDataDto {
+ return SaveDataDto.InventorySaveDataDto(
+ version = SAVE_DATA_VERSION,
+ size = inventory.size,
+ hotbarSize = inventory.hotbarSize,
+ activeSlot = inventory.activeSlot,
+ items = inventory.items.map(inventoryItemMapper::mapSaveData)
+ )
+ }
+
+ fun mapInventory(saveDataDto: SaveDataDto.InventorySaveDataDto): Inventory {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return Inventory(
+ size = saveDataDto.size,
+ hotbarSize = saveDataDto.hotbarSize,
+ fallbackItem = getFallbackItem(),
+ initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem)
+ ).apply {
+ activeSlot = saveDataDto.activeSlot
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.game.controller.mob.impl.MobControllerImpl
+import ru.fredboy.cavedroid.game.controller.mob.model.FallingBlock
+import ru.fredboy.cavedroid.game.controller.mob.model.Pig
+import javax.inject.Inject
+
+@Reusable
+class MobControllerMapper @Inject constructor(
+ private val pigMapper: PigMapper,
+ private val fallingBlockMapper: FallingBlockMapper,
+ private val playerMapper: PlayerMapper,
+ private val mobAssetsRepository: MobAssetsRepository,
+ private val getFallbackItemUseCase: GetFallbackItemUseCase,
+) {
+
+ fun mapSaveData(mobController: MobControllerImpl): SaveDataDto.MobControllerSaveDataDto {
+ return SaveDataDto.MobControllerSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ mobs = mobController.mobs.mapNotNull { mob ->
+ when (mob) {
+ is Pig -> pigMapper.mapSaveData(mob)
+ is FallingBlock -> fallingBlockMapper.mapSaveData(mob)
+ else -> null
+ }
+ },
+ player = playerMapper.mapSaveData(mobController.player)
+ )
+ }
+
+ fun mapMobController(saveDataDto: SaveDataDto.MobControllerSaveDataDto): MobControllerImpl {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return MobControllerImpl(
+ mobAssetsRepository = mobAssetsRepository,
+ getFallbackItemUseCase = getFallbackItemUseCase
+ ).apply {
+ (mobs as MutableList).addAll(saveDataDto.mobs.mapNotNull { mob ->
+ when (mob) {
+ is SaveDataDto.PigSaveDataDto -> pigMapper.mapPig(mob)
+ is SaveDataDto.FallingBlockSaveDataDto -> fallingBlockMapper.mapFallingBlock(mob)
+ else -> null
+ }
+ })
+
+ player = playerMapper.mapPlayer(saveDataDto.player)
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
+import ru.fredboy.cavedroid.game.controller.mob.model.Pig
+import javax.inject.Inject
+
+@Reusable
+class PigMapper @Inject constructor(
+ private val directionMapper: DirectionMapper,
+ private val getPigSpriteUseCase: GetPigSpritesUseCase
+) {
+
+ fun mapSaveData(pig: Pig): SaveDataDto.PigSaveDataDto {
+ return SaveDataDto.PigSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ x = pig.x,
+ y = pig.y,
+ width = pig.width,
+ height = pig.height,
+ velocityX = pig.velocity.x,
+ velocityY = pig.velocity.y,
+ animDelta = pig.animDelta,
+ anim = pig.anim,
+ direction = directionMapper.mapSaveData(pig.direction),
+ dead = pig.isDead,
+ canJump = pig.canJump,
+ flyMode = pig.isFlyMode,
+ maxHealth = pig.maxHealth,
+ health = pig.health
+ )
+ }
+
+ fun mapPig(saveDataDto: SaveDataDto.PigSaveDataDto): Pig {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return Pig(
+ sprite = getPigSpriteUseCase(),
+ x = saveDataDto.x,
+ y = saveDataDto.y
+ ).apply {
+ width = saveDataDto.width
+ height = saveDataDto.height
+ velocity.x = saveDataDto.velocityX
+ velocity.x = saveDataDto.velocityY
+ animDelta = saveDataDto.animDelta
+ anim = saveDataDto.anim
+ direction = directionMapper.mapDirection(saveDataDto.direction)
+ canJump = saveDataDto.canJump
+ isFlyMode = saveDataDto.flyMode
+ health = saveDataDto.health
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.save.mapper
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.assets.usecase.GetPlayerSpritesUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import javax.inject.Inject
+
+@Reusable
+class PlayerMapper @Inject constructor(
+ private val directionMapper: DirectionMapper,
+ private val inventoryMapper: InventoryMapper,
+ private val controlModeMapper: ControlModeMapper,
+ private val getPlayerSpritesUseCase: GetPlayerSpritesUseCase,
+ private val getFallbackItemUseCase: GetFallbackItemUseCase,
+) {
+
+ fun mapSaveData(player: Player): SaveDataDto.PlayerSaveDataDto {
+ return SaveDataDto.PlayerSaveDataDto(
+ version = SAVE_DATA_VERSION,
+ x = player.x,
+ y = player.y,
+ width = player.width,
+ height = player.height,
+ velocityX = player.velocity.x,
+ velocityY = player.velocity.y,
+ animDelta = player.animDelta,
+ anim = player.anim,
+ direction = directionMapper.mapSaveData(player.direction),
+ dead = player.isDead,
+ canJump = player.canJump,
+ flyMode = player.isFlyMode,
+ maxHealth = player.maxHealth,
+ health = player.health,
+ hitting = player.isHitting,
+ hittingWithDamage = player.isHittingWithDamage,
+ hitAnim = player.hitAnim,
+ hitAnimDelta = player.hitAnimDelta,
+ inventory = inventoryMapper.mapSaveData(player.inventory),
+ gameMode = player.gameMode,
+ swim = player.swim,
+ headRotation = player.headRotation,
+ blockDamage = player.blockDamage,
+ cursorX = player.cursorX,
+ cursorY = player.cursorY,
+ spawnPointX = 0f,
+ spawnPointY = 0f,
+ controlMode = controlModeMapper.mapSaveData(player.controlMode)
+ )
+ }
+
+ fun mapPlayer(saveDataDto: SaveDataDto.PlayerSaveDataDto): Player {
+ saveDataDto.verifyVersion(SAVE_DATA_VERSION)
+
+ return Player(
+ sprite = getPlayerSpritesUseCase(),
+ getFallbackItem = getFallbackItemUseCase,
+ x = saveDataDto.x,
+ y = saveDataDto.y
+ ).apply {
+ width = saveDataDto.width
+ height = saveDataDto.height
+ velocity.x = saveDataDto.velocityX
+ velocity.x = saveDataDto.velocityY
+ animDelta = saveDataDto.animDelta
+ anim = saveDataDto.anim
+ direction = directionMapper.mapDirection(saveDataDto.direction)
+ canJump = saveDataDto.canJump
+ isFlyMode = saveDataDto.flyMode
+ health = saveDataDto.health
+ isHitting = saveDataDto.hitting
+ isHittingWithDamage = saveDataDto.hittingWithDamage
+ hitAnim = saveDataDto.hitAnim
+ hitAnimDelta = saveDataDto.hitAnimDelta
+ inventory = inventoryMapper.mapInventory(saveDataDto.inventory)
+ gameMode = saveDataDto.gameMode
+ swim = saveDataDto.swim
+ headRotation = saveDataDto.headRotation
+ blockDamage = saveDataDto.blockDamage
+ cursorX = saveDataDto.cursorX
+ cursorY = saveDataDto.cursorY
+ controlMode = controlModeMapper.mapControlMode(saveDataDto.controlMode)
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 3
+ }
+}
\ No newline at end of file
-package ru.deadsoftware.cavedroid.game.model.dto
+package ru.fredboy.cavedroid.data.save.model
import kotlinx.serialization.Contextual
import kotlinx.serialization.Serializable
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.player.Player.ControlMode
@Serializable
sealed class SaveDataDto {
}
}
+ @Serializable
+ data class DirectionSaveDataDto(
+ override val version: Int,
+ val value: Int,
+ ) : SaveDataDto()
+
+ @Serializable
+ data class ControlModeSaveDataDto(
+ override val version: Int,
+ val value: Int,
+ ) : SaveDataDto()
+
@Serializable
sealed class ContainerSaveDataDto : SaveDataDto() {
abstract val size: Int
- abstract val items: List<InventoryItemSaveData>
+ abstract val items: List<InventoryItemSaveDataDto>
}
@Serializable
@Serializable
sealed class MobSaveDataDto : RectangleObjectSaveDataDto() {
- abstract val type: Mob.Type
- abstract val animDelta: Int
+ abstract val animDelta: Float
abstract val anim: Float
- abstract val direction: Mob.Direction
+ abstract val direction: DirectionSaveDataDto
abstract val dead: Boolean
abstract val canJump: Boolean
abstract val flyMode: Boolean
}
@Serializable
- data class InventoryItemSaveData(
+ data class InventoryItemSaveDataDto(
override val version: Int,
val itemKey: String,
val amount: Int,
) : SaveDataDto()
@Serializable
- data class InventorySaveData(
+ data class InventorySaveDataDto(
override val version: Int,
override val size: Int,
val hotbarSize: Int,
val activeSlot: Int,
- override val items: List<InventoryItemSaveData>,
+ override val items: List<InventoryItemSaveDataDto>,
) : ContainerSaveDataDto()
@Serializable
- data class FurnaceSaveData(
+ data class FurnaceSaveDataDto(
override val version: Int,
override val size: Int,
val currentFuelItemKey: String?,
- override val items: List<InventoryItemSaveData>,
+ override val items: List<InventoryItemSaveDataDto>,
val startBurnTimeMs: Long,
val startSmeltTimeMs: Long,
val burnProgress: Float,
) : ContainerSaveDataDto()
@Serializable
- data class ChestSaveData(
+ data class ChestSaveDataDto(
override val version: Int,
override val size: Int,
- override val items: List<InventoryItemSaveData>
+ override val items: List<InventoryItemSaveDataDto>
) : ContainerSaveDataDto()
@Serializable
- data class ContainerControllerSaveData(
+ data class ContainerControllerSaveDataDto(
override val version: Int,
val containerMap: Map<String, @Contextual ContainerSaveDataDto>,
- ): SaveDataDto()
+ ) : SaveDataDto()
@Serializable
- data class DropSaveData(
+ data class DropSaveDataDto(
override val version: Int,
override val x: Float,
override val y: Float,
val amount: Int,
val pickedUp: Boolean
) : RectangleObjectSaveDataDto()
-
+
@Serializable
- data class DropControllerSaveData(
+ data class DropControllerSaveDataDto(
override val version: Int,
- val drops: List<DropSaveData>
+ val drops: List<DropSaveDataDto>
) : SaveDataDto()
-
+
@Serializable
- data class PigSaveData(
+ data class PigSaveDataDto(
override val version: Int,
override val x: Float,
override val y: Float,
override val height: Float,
override val velocityX: Float,
override val velocityY: Float,
- override val type: Mob.Type,
- override val animDelta: Int,
+ override val animDelta: Float,
override val anim: Float,
- override val direction: Mob.Direction,
+ override val direction: DirectionSaveDataDto,
override val dead: Boolean,
override val canJump: Boolean,
override val flyMode: Boolean,
) : MobSaveDataDto()
@Serializable
- data class FallingBlockSaveData(
+ data class FallingBlockSaveDataDto(
override val version: Int,
override val x: Float,
override val y: Float,
override val height: Float,
override val velocityX: Float,
override val velocityY: Float,
- override val type: Mob.Type,
- override val animDelta: Int,
+ override val animDelta: Float,
override val anim: Float,
- override val direction: Mob.Direction,
+ override val direction: DirectionSaveDataDto,
override val dead: Boolean,
override val canJump: Boolean,
override val flyMode: Boolean,
) : MobSaveDataDto()
@Serializable
- data class PlayerSaveData(
+ data class PlayerSaveDataDto(
override val version: Int,
- override val type: Mob.Type,
- override val animDelta: Int,
+ override val animDelta: Float,
override val anim: Float,
- override val direction: Mob.Direction,
+ override val direction: DirectionSaveDataDto,
override val dead: Boolean,
override val canJump: Boolean,
override val flyMode: Boolean,
val hittingWithDamage: Boolean,
val hitAnim: Float,
val hitAnimDelta: Float,
- val inventory: InventorySaveData,
+ val inventory: InventorySaveDataDto,
val gameMode: Int,
val swim: Boolean,
val headRotation: Float,
val cursorY: Int,
val spawnPointX: Float,
val spawnPointY: Float,
- val controlMode: ControlMode,
+ val controlMode: ControlModeSaveDataDto,
) : MobSaveDataDto()
@Serializable
- data class MobsControllerSaveData(
+ data class MobControllerSaveDataDto(
override val version: Int,
val mobs: List<@Contextual MobSaveDataDto>,
- val player: PlayerSaveData,
+ val player: PlayerSaveDataDto,
) : SaveDataDto()
-
+
}
\ No newline at end of file
-package ru.deadsoftware.cavedroid.game.save
+package ru.fredboy.cavedroid.data.save.repository
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.files.FileHandle
-import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.decodeFromByteArray
import kotlinx.serialization.encodeToByteArray
import kotlinx.serialization.protobuf.ProtoBuf
-import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
-import ru.deadsoftware.cavedroid.game.objects.container.ContainerController
-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 ru.fredboy.cavedroid.data.save.mapper.ContainerControllerMapper
+import ru.fredboy.cavedroid.data.save.mapper.DropControllerMapper
+import ru.fredboy.cavedroid.data.save.mapper.MobControllerMapper
+import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.domain.save.model.GameSaveData
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.impl.ContainerControllerImpl
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.impl.MobControllerImpl
+import ru.fredboy.cavedroid.game.world.GameWorld
import java.nio.ByteBuffer
import java.util.zip.GZIPInputStream
import java.util.zip.GZIPOutputStream
+import javax.inject.Inject
-@OptIn(ExperimentalSerializationApi::class)
-object GameSaveLoader {
-
- private const val MAP_SAVE_VERSION: UByte = 2u
-
- private const val SAVES_DIR = "/saves"
- private const val DROP_FILE = "/drop.dat"
- private const val MOBS_FILE = "/mobs.dat"
- private const val CONTAINERS_FILE = "/containers.dat"
- private const val DICT_FILE = "/dict"
- private const val FOREMAP_FILE = "/foremap.dat.gz"
- private const val BACKMAP_FILE = "/backmap.dat.gz"
+internal class SaveDataRepositoryImpl @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+ private val dropControllerMapper: DropControllerMapper,
+ private val containerControllerMapper: ContainerControllerMapper,
+ private val mobControllerMapper: MobControllerMapper,
+) : SaveDataRepository {
private fun Int.toByteArray(): ByteArray {
return ByteBuffer.allocate(Int.SIZE_BYTES)
file.writeBytes(result, false)
}
+
private fun compressMap(map: Array<Array<Block>>, dict: Map<String, Int>): ByteArray {
if (dict.size > 0xff) {
throw IllegalArgumentException("Cannot save this map as bytes")
private fun decompressMap(
bytes: ByteArray,
dict: List<String>,
- gameItemsHolder: GameItemsHolder
+ itemsRepository: ItemsRepository,
): Array<Array<Block>> {
val version = bytes.first().toUByte()
require(version == MAP_SAVE_VERSION)
val blockId = bytes[i + Int.SIZE_BYTES].toUByte().toInt()
for (j in 0 ..< run) {
- add(gameItemsHolder.getBlock(dict[blockId]))
+ add(itemsRepository.getBlockByKey(dict[blockId]))
}
}
}
}
}
+
private fun loadMap(
- gameItemsHolder: GameItemsHolder,
+ itemsRepository: ItemsRepository,
savesPath: String
): Pair<Array<Array<Block>>, Array<Array<Block>>> {
val dict = Gdx.files.absolute("$savesPath$DICT_FILE").readString().split("\n")
val foreMap: Array<Array<Block>>
with(GZIPInputStream(Gdx.files.absolute("$savesPath$FOREMAP_FILE").read())) {
- foreMap = decompressMap(readBytes(), dict, gameItemsHolder)
+ foreMap = decompressMap(readBytes(), dict, itemsRepository)
close()
}
val backMap: Array<Array<Block>>
with(GZIPInputStream(Gdx.files.absolute("$savesPath$BACKMAP_FILE").read())) {
- backMap = decompressMap(readBytes(), dict, gameItemsHolder)
+ backMap = decompressMap(readBytes(), dict, itemsRepository)
close()
}
}
private fun saveMap(gameWorld: GameWorld, savesPath: String) {
- val fullForeMap = gameWorld.fullForeMap
- val fullBackMap = gameWorld.fullBackMap
+ val fullForeMap = gameWorld.foreMap
+ val fullBackMap = gameWorld.backMap
val dict = buildBlocksDictionary(fullForeMap, fullBackMap)
}
}
- fun load(
- mainConfig: MainConfig,
- gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager,
- getPlayerSprites: GetPlayerSpritesUseCase,
- getPigSprites: GetPigSpritesUseCase,
- ): GameSaveData {
- val gameFolder = mainConfig.gameFolder
- val savesPath = "$gameFolder$SAVES_DIR"
+ override fun save(
+ gameDataFolder: String,
+ dropController: DropController,
+ mobController: MobController,
+ containerController: ContainerController,
+ gameWorld: GameWorld
+ ) {
+ val savesPath = "$gameDataFolder$SAVES_DIR"
+
+ Gdx.files.absolute(savesPath).mkdirs()
+
+ val dropFile = Gdx.files.absolute("$savesPath$DROP_FILE")
+ val mobsFile = Gdx.files.absolute("$savesPath$MOBS_FILE")
+ val containersFile = Gdx.files.absolute("$savesPath$CONTAINERS_FILE")
+
+ val dropBytes = ProtoBuf.encodeToByteArray(dropControllerMapper.mapSaveData(dropController))
+ val mobsBytes = ProtoBuf.encodeToByteArray(mobControllerMapper.mapSaveData(mobController as MobControllerImpl))
+ val containersBytes = ProtoBuf.encodeToByteArray(containerControllerMapper.mapSaveData(containerController as ContainerControllerImpl))
+
+ dropFile.writeBytes(dropBytes, false)
+ mobsFile.writeBytes(mobsBytes, false)
+ containersFile.writeBytes(containersBytes, false)
+
+ saveMap(gameWorld, savesPath)
+ }
+
+ override fun load(gameDataFolder: String): GameSaveData {
+ val savesPath = "$gameDataFolder$SAVES_DIR"
val dropFile = Gdx.files.absolute("$savesPath$DROP_FILE")
val mobsFile = Gdx.files.absolute("$savesPath$MOBS_FILE")
val mobsBytes = mobsFile.readBytes()
val containersBytes = containersFile.readBytes()
- val dropController = ProtoBuf.decodeFromByteArray<SaveDataDto.DropControllerSaveData>(dropBytes)
+ val dropController = ProtoBuf.decodeFromByteArray<SaveDataDto.DropControllerSaveDataDto>(dropBytes)
.let { saveData ->
- DropController.fromSaveData(
- /* saveData = */ saveData,
- /* gameItemsHolder = */ gameItemsHolder
- )
+ dropControllerMapper.mapDropController(saveData)
}
- val mobsController = ProtoBuf.decodeFromByteArray<SaveDataDto.MobsControllerSaveData>(mobsBytes)
+ val mobController = ProtoBuf.decodeFromByteArray<SaveDataDto.MobControllerSaveDataDto>(mobsBytes)
.let { saveData ->
- MobsController.fromSaveData(
- saveData = saveData,
- gameItemsHolder = gameItemsHolder,
- tooltipManager = tooltipManager,
- getPigSprites = getPigSprites,
- getPlayerSprites = getPlayerSprites
- )
+ mobControllerMapper.mapMobController(saveData)
}
- val containerController = ProtoBuf.decodeFromByteArray<SaveDataDto.ContainerControllerSaveData>(containersBytes)
+ val containerController = ProtoBuf.decodeFromByteArray<SaveDataDto.ContainerControllerSaveDataDto>(containersBytes)
.let { saveData ->
- ContainerController.fromSaveData(
- saveData = saveData,
- dropController = dropController,
- gameItemsHolder = gameItemsHolder
- )
+ containerControllerMapper.mapContainerController(saveData)
}
- val (foreMap, backMap) = loadMap(gameItemsHolder, savesPath)
+ val (foreMap, backMap) = loadMap(itemsRepository, savesPath)
- return GameSaveData(mobsController, dropController, containerController, foreMap, backMap)
+ return GameSaveData(mobController, dropController, containerController, foreMap, backMap)
}
- fun save(
- mainConfig: MainConfig,
- dropController: DropController,
- mobsController: MobsController,
- containerController: ContainerController,
- gameWorld: GameWorld
- ) {
- val gameFolder = mainConfig.gameFolder
- val savesPath = "$gameFolder$SAVES_DIR"
-
- Gdx.files.absolute(savesPath).mkdirs()
-
- val dropFile = Gdx.files.absolute("$savesPath$DROP_FILE")
- val mobsFile = Gdx.files.absolute("$savesPath$MOBS_FILE")
- val containersFile = Gdx.files.absolute("$savesPath$CONTAINERS_FILE")
-
- val dropBytes = ProtoBuf.encodeToByteArray(dropController.getSaveData())
- val mobsBytes = ProtoBuf.encodeToByteArray(mobsController.getSaveData())
- val containersBytes = ProtoBuf.encodeToByteArray(containerController.getSaveData())
-
- dropFile.writeBytes(dropBytes, false)
- mobsFile.writeBytes(mobsBytes, false)
- containersFile.writeBytes(containersBytes, false)
-
- saveMap(gameWorld, savesPath)
- }
-
- fun exists(mainConfig: MainConfig): Boolean {
- val gameFolder = mainConfig.gameFolder
- val savesPath = "$gameFolder$SAVES_DIR"
+ override fun exists(gameDataFolder: String,): Boolean {
+ val savesPath = "$gameDataFolder$SAVES_DIR"
return Gdx.files.absolute("$savesPath$DROP_FILE").exists() &&
Gdx.files.absolute("$savesPath$MOBS_FILE").exists() &&
Gdx.files.absolute("$savesPath$BACKMAP_FILE").exists()
}
+ companion object {
+ private const val MAP_SAVE_VERSION: UByte = 2u
+ private const val SAVES_DIR = "/saves"
+ private const val DROP_FILE = "/drop.dat"
+ private const val MOBS_FILE = "/mobs.dat"
+ private const val CONTAINERS_FILE = "/containers.dat"
+ private const val DICT_FILE = "/dict"
+ private const val FOREMAP_FILE = "/foremap.dat.gz"
+ private const val BACKMAP_FILE = "/backmap.dat.gz"
+ }
}
\ No newline at end of file
java.targetCompatibility = ApplicationInfo.sourceCompatibility
dependencies {
- useBaseModule()
+ useCommonModule()
useLibgdx()
useDagger()
}
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useCommonModule()
+ useLibgdx()
+ useDagger()
+}
-package ru.deadsoftware.cavedroid.game.model.block
+package ru.fredboy.cavedroid.domain.items.model.block
import com.badlogic.gdx.graphics.g2d.Sprite
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.math.Rectangle
import com.badlogic.gdx.utils.TimeUtils
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.misc.utils.colorFromHexString
+import ru.fredboy.cavedroid.common.utils.BLOCK_SIZE_PX
+import ru.fredboy.cavedroid.common.utils.colorFromHexString
+import ru.fredboy.cavedroid.domain.items.model.item.Item
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
abstract val params: CommonBlockParams
- val width: Float get() = 16f - params.collisionMargins.left - params.collisionMargins.right
- val height: Float get() = 16f - params.collisionMargins.top - params.collisionMargins.bottom
+ val width: Float get() = BLOCK_SIZE_PX - params.collisionMargins.left - params.collisionMargins.right
+ val height: Float get() = BLOCK_SIZE_PX - params.collisionMargins.top - params.collisionMargins.bottom
- val spriteWidth: Float get() = 16f - params.spriteMargins.left - params.spriteMargins.right
- val spriteHeight: Float get() = 16f - params.spriteMargins.top - params.spriteMargins.bottom
+ val spriteWidth: Float get() = BLOCK_SIZE_PX - params.spriteMargins.left - params.spriteMargins.right
+ val spriteHeight: Float get() = BLOCK_SIZE_PX - params.spriteMargins.top - params.spriteMargins.bottom
protected var animation: Array<Sprite>? = null
fun getRectangle(x: Int, y: Int): Rectangle {
return Rectangle(
- /* x = */ x * 16f + params.collisionMargins.left,
- /* y = */ y * 16f + params.collisionMargins.top,
+ /* x = */ x * BLOCK_SIZE_PX + params.collisionMargins.left,
+ /* y = */ y * BLOCK_SIZE_PX + params.collisionMargins.top,
/* width = */ width,
/* height = */ height
)
override val state: Int,
) : Fluid()
- /* Legacy accessors below */
-
- // collision margins
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val left: Int get() = params.collisionMargins.left
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val right: Int get() = params.collisionMargins.left
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val top: Int get() = params.collisionMargins.left
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val bottom: Int get() = params.collisionMargins.left
-
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val hp: Int get() = params.hitPoints
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val collision: Boolean get() = params.hasCollision
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val animated: Boolean get() = params.animationInfo != null
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val frames: Int get() = params.animationInfo?.framesCount ?: 0
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) val drop: String get() = params.dropInfo?.itemKey ?: "none"
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) fun hasDrop() = params.dropInfo != null
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) fun toJump() = params.hasCollision && params.collisionMargins.top < 8
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) fun hasCollision() = params.hasCollision
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) fun isBackground() = params.isBackground
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) fun isTransparent() = params.isTransparent
- @Deprecated(LEGACY_ACCESSOR_DEPRECATION) fun getTexture() = sprite
-
companion object {
- private const val LEGACY_ACCESSOR_DEPRECATION = "legacy accessors will be removed"
private const val ANIMATION_FRAME_DURATION_MS = 100L
}
}
\ No newline at end of file
-package ru.deadsoftware.cavedroid.game.model.block
+package ru.fredboy.cavedroid.domain.items.model.block
data class BlockAnimationInfo(
val framesCount: Int
-package ru.deadsoftware.cavedroid.game.model.block
+package ru.fredboy.cavedroid.domain.items.model.block
data class BlockDropInfo(
val itemKey: String,
-package ru.deadsoftware.cavedroid.game.model.block
+package ru.fredboy.cavedroid.domain.items.model.block
data class BlockMargins(
val left: Int,
-package ru.deadsoftware.cavedroid.game.model.block
+package ru.fredboy.cavedroid.domain.items.model.block
import com.badlogic.gdx.graphics.Texture
-import ru.deadsoftware.cavedroid.game.model.item.Item
+import ru.fredboy.cavedroid.domain.items.model.item.Item
data class CommonBlockParams(
val key: String,
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.model.craft
+
+data class CraftingRecipe(
+ val input: List<Regex>,
+ val output: CraftingResult
+)
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.model.craft
+
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+
+data class CraftingResult(
+ val item: Item,
+ val amount: Int,
+) {
+ fun toInventoryItem() = InventoryItem(item, amount)
+}
-package ru.deadsoftware.cavedroid.game.model.item
+package ru.fredboy.cavedroid.domain.items.model.item
-import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin
+import ru.fredboy.cavedroid.common.model.SpriteOrigin
data class CommonItemParams(
val key: String,
val maxStack: Int,
val burningTimeMs: Long?,
val smeltProductKey: String?,
-)
\ No newline at end of file
+)
-package ru.deadsoftware.cavedroid.game.model.item
+package ru.fredboy.cavedroid.domain.items.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.game.model.dto.SaveDataDto
-import ru.deadsoftware.cavedroid.misc.Assets
-import ru.deadsoftware.cavedroid.misc.Saveable
-import ru.deadsoftware.cavedroid.misc.utils.drawSprite
-import ru.deadsoftware.cavedroid.misc.utils.drawString
-import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
-import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.utils.drawSprite
+import ru.fredboy.cavedroid.common.utils.drawString
+import ru.fredboy.cavedroid.common.utils.px
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
-class InventoryItem @JvmOverloads constructor(
- val itemKey: String,
+class InventoryItem(
+ val item: Item,
_amount: Int = 1,
-) : Saveable {
+) {
var amount = _amount
set(value) {
}
}
- private var _item: Item? = null
-
- var item: Item
- get() {
- requireNotNull(_item) { "_item is null" }
- return _item.takeIf { amount > 0 } ?: throw IllegalArgumentException("Accessing item with zero amount")
- }
- private set (value) {
- _item = value
- }
-
- @JvmOverloads
- constructor(item: Item, amount: Int = 1) : this(item.params.key, amount) {
- _item = item
- }
-
- fun init(gameItemsHolder: GameItemsHolder) {
- if (_item != null) {
- return
- }
- _item = gameItemsHolder.getItem(itemKey)
- }
-
- @JvmOverloads
fun add(count: Int = 1) {
if (count > 0 && Int.MAX_VALUE - count < amount) {
throw IllegalArgumentException("$amount + $count exceeds Int.MAX_VALUE")
amount += count
}
- @JvmOverloads
fun subtract(count: Int = 1) {
if (count < 0) {
throw IllegalArgumentException("Can't subtract negative amount")
add(-count)
}
- @JvmOverloads
fun canBeAdded(count: Int = 1): Boolean {
return amount + count <= item.params.maxStack
}
- private fun drawAmountText(spriteBatch: SpriteBatch, font: BitmapFont, text: String, x: Float, y: Float) {
+ 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)
}
font: BitmapFont,
x: Float,
y: Float,
- getStringWidth: GetStringWidthUseCase,
- getStringHeight: GetStringHeightUseCase,
+ getStringWidth: (String) -> Float,
+ getStringHeight: (String) -> Float,
) {
if (item.isNone()) {
return
font: BitmapFont,
x: Float,
y: Float,
- getStringWidth: GetStringWidthUseCase,
- getStringHeight: GetStringHeightUseCase,
+ getStringWidth: (String) -> Float,
+ getStringHeight: (String) -> Float,
) {
if (item.isNone()) {
return
}
}
- override fun getSaveData(): SaveDataDto.InventoryItemSaveData {
- return SaveDataDto.InventoryItemSaveData(
- version = SAVE_DATA_VERSION,
- itemKey = itemKey,
- amount = amount,
- )
- }
-
companion object {
- private const val SAVE_DATA_VERSION = 1
-
@OptIn(ExperimentalContracts::class)
fun InventoryItem?.isNoneOrNull(): Boolean {
contract { returns(false) implies(this@isNoneOrNull != null) }
return this?.item == null || this.item.isNone()
}
-
-
- fun fromSaveData(
- saveData: SaveDataDto.InventoryItemSaveData,
- gameItemsHolder: GameItemsHolder? = null
- ): InventoryItem {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- val inventoryItem = InventoryItem(saveData.itemKey, saveData.amount)
- gameItemsHolder?.let(inventoryItem::init)
-
- return inventoryItem
- }
}
}
-package ru.deadsoftware.cavedroid.game.model.item
+package ru.fredboy.cavedroid.domain.items.model.item
import com.badlogic.gdx.graphics.g2d.Sprite
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.model.block.Block as BlockModel
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
+import ru.fredboy.cavedroid.domain.items.model.block.Block as DomainBlockModel
@OptIn(ExperimentalContracts::class)
sealed class Item {
contract { returns(true) implies (this@Item is None) }
return this is None
}
-
+
fun isPlaceable(): Boolean {
contract { returns(true) implies (this@Item is Placeable) }
return this is Placeable
}
sealed class Placeable : Item() {
- abstract val block: BlockModel
+ abstract val block: DomainBlockModel
override val sprite: Sprite get() = block.sprite
}
data class Block(
override val params: CommonItemParams,
- override val block: BlockModel
+ override val block: DomainBlockModel
) : Placeable()
data class Slab(
override val params: CommonItemParams,
- val topPartBlock: BlockModel.Slab,
- val bottomPartBlock: BlockModel.Slab
+ val topPartBlock: DomainBlockModel.Slab,
+ val bottomPartBlock: DomainBlockModel.Slab
) : Placeable() {
override val block get() = bottomPartBlock
}
-
+
data class Sword(
override val params: CommonItemParams,
override val sprite: Sprite,
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.repository
+
+import com.badlogic.gdx.utils.Disposable
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+
+interface ItemsRepository : Disposable {
+
+ val fallbackBlock: Block.None
+
+ val fallbackItem: Item.None
+
+ fun initialize()
+
+ fun getItemByKey(key: String): Item
+
+ fun getItemByIndex(index: Int): Item
+
+ fun getBlockByKey(key: String): Block
+
+ fun <T : Block> getBlocksByType(type: Class<T>): List<T>
+
+ fun getCraftingResult(input: List<Item>): InventoryItem
+
+ fun getAllItems(): Collection<Item>
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class DisposeItemsRepositoryUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun invoke() {
+ itemsRepository.dispose()
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class GetBlockByKeyUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun get(key: String): Block {
+ return itemsRepository.getBlockByKey(key)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class GetBlocksByTypeUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun <T : Block> get(type: Class<T>): List<T> {
+ return itemsRepository.getBlocksByType(type)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class GetCraftingResultUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun get(input: List<Item>): InventoryItem {
+ return itemsRepository.getCraftingResult(input)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class GetFallbackItemUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository
+) {
+
+ operator fun invoke(): Item.None {
+ return itemsRepository.fallbackItem
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class GetItemByIndexUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun get(index: Int): Item {
+ return itemsRepository.getItemByIndex(index)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class GetItemByKeyUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun get(key: String): Item {
+ return itemsRepository.getItemByKey(key)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.items.usecase
+
+import dagger.Reusable
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import javax.inject.Inject
+
+@Reusable
+class InitializeItemsRepositoryUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun invoke() {
+ itemsRepository.initialize()
+ }
+
+}
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useCommonModule()
+ useLibgdx()
+ useDagger()
+
+ useModule(":core:domain:items")
+ useModule(":core:domain:assets")
+
+ useModule(":core:game:controller:container")
+ useModule(":core:game:controller:drop")
+ useModule(":core:game:controller:mob")
+ useModule(":core:game:world")
+}
-package ru.deadsoftware.cavedroid.game.save
+package ru.fredboy.cavedroid.domain.save.model
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.objects.container.ContainerController
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
class GameSaveData(
- private var mobsController: MobsController?,
+ private var mobController: MobController?,
private var dropController: DropController?,
private var containerController: ContainerController?,
private var foreMap: Array<Array<Block>>?,
private var backMap: Array<Array<Block>>?
) {
- fun retrieveMobsController(): MobsController {
- val value = requireNotNull(mobsController)
- mobsController = null
+ fun retrieveMobsController(): MobController {
+ val value = requireNotNull(mobController)
+ mobController = null
return value
}
}
fun isEmpty(): Boolean {
- return mobsController == null &&
+ return mobController == null &&
dropController == null &&
containerController == null &&
foreMap == null &&
--- /dev/null
+package ru.fredboy.cavedroid.domain.save.repository
+
+import ru.fredboy.cavedroid.domain.save.model.GameSaveData
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
+
+interface SaveDataRepository {
+
+ fun save(
+ gameDataFolder: String,
+ dropController: DropController,
+ mobController: MobController,
+ containerController: ContainerController,
+ gameWorld: GameWorld
+ )
+
+ fun load(
+ gameDataFolder: String,
+ ): GameSaveData
+
+ fun exists(gameDataFolder: String): Boolean
+
+}
\ No newline at end of file
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:items")
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container
+
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerAddedListener
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerRemovedListener
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+
+interface ContainerController {
+
+ val size: Int
+
+ fun getContainer(x: Int, y: Int, z: Int): Container?
+
+ fun addContainer(x: Int, y: Int, z: Int, container: Container)
+
+ /**
+ * Removes container without notifying listeners
+ */
+ fun resetContainer(x: Int, y: Int, z: Int)
+
+ /**
+ * Removes container and notifies listeners
+ */
+ fun destroyContainer(x: Int, y: Int, z: Int)
+
+ fun addContainerAddedListener(listener: ContainerAddedListener)
+
+ fun removeContainerAddedListener(listener: ContainerAddedListener)
+
+ fun addContainerRemovedListener(listener: ContainerRemovedListener)
+
+ fun removeContainerRemovedListener(listener: ContainerRemovedListener)
+
+ fun update(delta: Float)
+
+ fun dispose()
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.impl.ContainerControllerImpl
+
+@Module
+abstract class ControllerContainerModule {
+
+ @Binds
+ internal abstract fun bindContainerController(impl: ContainerControllerImpl): ContainerController
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.impl
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerAddedListener
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerRemovedListener
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import javax.inject.Inject
+
+@GameScope
+class ContainerControllerImpl @Inject constructor(
+ private val itemByKey: GetItemByKeyUseCase,
+) : ContainerController {
+
+ val containerMap = mutableMapOf<String, Container>()
+
+ private val containerAddedListeners = mutableSetOf<ContainerAddedListener>()
+ private val containerRemovedListeners = mutableSetOf<ContainerRemovedListener>()
+
+ override val size get() = containerMap.size
+
+ private fun getContainerKey(x: Int, y: Int, z: Int): String {
+ return "$x;$y;$z"
+ }
+
+ override fun getContainer(x: Int, y: Int, z: Int): Container? {
+ return containerMap[getContainerKey(x, y, z)]
+ }
+
+ override fun addContainer(x: Int, y: Int, z: Int, container: Container) {
+ val key = getContainerKey(x, y, z)
+ if (containerMap.containsKey(key)) {
+ resetContainer(x, y, z)
+ }
+
+ containerMap[key] = container
+
+ containerAddedListeners.forEach { listener ->
+ listener.onContainerAdded(x, y, z, container)
+ }
+ }
+
+ private fun retrieveContainer(x: Int, y: Int, z: Int): Container? {
+ return containerMap.remove(getContainerKey(x, y, z))
+ }
+
+ override fun resetContainer(x: Int, y: Int, z: Int) {
+ retrieveContainer(x, y, z)
+ }
+
+ override fun destroyContainer(x: Int, y: Int, z: Int) {
+ retrieveContainer(x, y, z)?.let { container ->
+ containerRemovedListeners.forEach { listener ->
+ listener.onContainerRemoved(x, y, z, container)
+ }
+ }
+ }
+
+ override fun addContainerAddedListener(listener: ContainerAddedListener) {
+ containerAddedListeners.add(listener)
+ }
+
+ override fun removeContainerAddedListener(listener: ContainerAddedListener) {
+ containerAddedListeners.remove(listener)
+ }
+
+ override fun addContainerRemovedListener(listener: ContainerRemovedListener) {
+ containerRemovedListeners.add(listener)
+ }
+
+ override fun removeContainerRemovedListener(listener: ContainerRemovedListener) {
+ containerRemovedListeners.remove(listener)
+ }
+
+ override fun update(delta: Float) {
+ containerMap.values.forEach { container ->
+ container.update(itemByKey)
+ }
+ }
+
+ override fun dispose() {
+ containerAddedListeners.clear()
+ containerRemovedListeners.clear()
+ containerMap.clear()
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.listener
+
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+
+fun interface ContainerAddedListener {
+
+ fun onContainerAdded(x: Int, y: Int, z: Int, container: Container)
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.listener
+
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+
+fun interface ContainerRemovedListener {
+
+ fun onContainerRemoved(x: Int, y: Int, z: Int, container: Container)
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.model
+
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+
+class Chest(
+ fallbackItem: Item,
+ initialItems: List<InventoryItem>? = null,
+) : Container(
+ size = SIZE,
+ fallbackItem = fallbackItem,
+ initialItems = initialItems
+) {
+
+ override fun update(itemByKey: GetItemByKeyUseCase) {
+ // no-op
+ }
+
+ companion object {
+ private const val SIZE = 27
+ }
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.model
+
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+
+abstract class Container(
+ val size: Int,
+ protected val fallbackItem: Item,
+ initialItems: List<InventoryItem>? = null
+) {
+
+ private val _items = Array(size) { index ->
+ initialItems?.getOrNull(index) ?: fallbackItem.toInventoryItem()
+ }
+
+ val items get() = _items.asList() as MutableList<InventoryItem>
+
+ abstract fun update(itemByKey: GetItemByKeyUseCase)
+
+}
\ No newline at end of file
-package ru.deadsoftware.cavedroid.game.objects.container
+package ru.fredboy.cavedroid.game.controller.container.model
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.math.MathUtils
import com.badlogic.gdx.utils.TimeUtils
-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.game.model.item.InventoryItem.Companion.isNoneOrNull
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.misc.Saveable
-
-class Furnace @JvmOverloads constructor(
- gameItemsHolder: GameItemsHolder,
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem.Companion.isNoneOrNull
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+
+class Furnace(
+ fallbackItem: Item,
initialItems: List<InventoryItem>? = null
-) : Container(SIZE, gameItemsHolder, initialItems), Saveable {
+) : Container(
+ size = SIZE,
+ fallbackItem = fallbackItem,
+ initialItems = initialItems,
+) {
var fuel: InventoryItem
get() = items[FUEL_INDEX]
var currentFuelKey: String? = null
- private var startBurnTimeMs = 0L
- private var smeltStarTimeMs = 0L
+ var startBurnTimeMs = 0L
+ var smeltStarTimeMs = 0L
var burnProgress = 0f
- private set(value) {
+ set(value) {
field = MathUtils.clamp(value, 0f, 1f)
}
var smeltProgress = 0f
- private set(value) {
+ set(value) {
field = MathUtils.clamp(value, 0f, 1f)
}
- fun init(gameItemsHolder: GameItemsHolder) {
- currentFuel = currentFuelKey?.let { gameItemsHolder.getItem(it) }
- items.forEach { it.init(gameItemsHolder) }
- }
fun canSmelt(): Boolean {
return (result.isNoneOrNull() || (result.item.params.key == input.item.params.smeltProductKey)) &&
(!fuel.isNoneOrNull() || burnProgress > 0f)
}
- private fun startBurning(gameItemsHolder: GameItemsHolder) {
+ private fun startBurning() {
requireNotNull(fuel.item.params.burningTimeMs) { "Cant start burning without fuel" }
currentFuel = fuel.item
fuel.subtract()
if (fuel.amount <= 0) {
- fuel = gameItemsHolder.fallbackItem.toInventoryItem()
+ fuel = fallbackItem.toInventoryItem()
}
startBurnTimeMs = TimeUtils.millis()
burnProgress = 0f
}
- override fun update(gameItemsHolder: GameItemsHolder) {
+ override fun update(itemByKey: GetItemByKeyUseCase) {
if (currentFuel?.isNone() == true) {
currentFuel = null
}
if (currentFuel?.isNone() == false && burnProgress >= 1f) {
if (canSmelt()) {
- startBurning(gameItemsHolder)
+ startBurning()
} else {
currentFuel = null
burnProgress = 0f
return
}
if (currentFuel == null && !fuel.isNoneOrNull()) {
- startBurning(gameItemsHolder)
+ startBurning()
smeltStarTimeMs = startBurnTimeMs
smeltProgress = 0f
}
if (isActive && smeltProgress >= 1f) {
val productKey = requireNotNull(input.item.params.smeltProductKey)
- val res = gameItemsHolder.getItem(productKey)
+ val res = itemByKey[productKey]
if (result.isNoneOrNull()) {
result = res.toInventoryItem()
} else {
}
input.subtract()
if (input.amount <= 0) {
- input = gameItemsHolder.fallbackItem.toInventoryItem()
+ input = fallbackItem.toInventoryItem()
}
smeltStarTimeMs = TimeUtils.millis()
smeltProgress = 0f
}
}
- override fun getSaveData(): SaveDataDto.FurnaceSaveData {
- return SaveDataDto.FurnaceSaveData(
- version = SAVE_DATA_VERSION,
- size = size,
- currentFuelItemKey = currentFuelKey,
- items = items.map(InventoryItem::getSaveData),
- startBurnTimeMs = startBurnTimeMs,
- startSmeltTimeMs = smeltStarTimeMs,
- burnProgress = burnProgress,
- smeltProgress = smeltProgress,
- )
- }
-
companion object {
- private const val SAVE_DATA_VERSION = 1
private const val SIZE = 3
private const val TAG = "Furnace"
const val RESULT_INDEX = 2
const val SMELTING_TIME_MS = 10000L
-
- fun fromSaveData(saveData: SaveDataDto.FurnaceSaveData, gameItemsHolder: GameItemsHolder): Furnace {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return Furnace(
- gameItemsHolder = gameItemsHolder,
- initialItems = saveData.items.map { item ->
- InventoryItem.fromSaveData(item, gameItemsHolder)
- }
- ).apply {
- currentFuelKey = saveData.currentFuelItemKey
- startBurnTimeMs = saveData.startSmeltTimeMs
- smeltStarTimeMs = saveData.startSmeltTimeMs
- burnProgress = saveData.burnProgress
- smeltProgress = saveData.smeltProgress
- }
- }
}
}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerAddedListener
+import javax.inject.Inject
+
+class AddContainerAddedListenerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(containerAddedListener: ContainerAddedListener) {
+ containerController.addContainerAddedListener(containerAddedListener)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerRemovedListener
+import javax.inject.Inject
+
+class AddContainerRemovedListenerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(containerRemovedListener: ContainerRemovedListener) {
+ containerController.addContainerRemovedListener(containerRemovedListener)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+import javax.inject.Inject
+
+class AddContainerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(x: Int, y: Int, z: Int, container: Container) {
+ containerController.addContainer(x, y, z, container)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import javax.inject.Inject
+
+class DestroyContainerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(x: Int, y: Int, z: Int) {
+ containerController.destroyContainer(x, y, z)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import javax.inject.Inject
+
+class DisposeContainerControllerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke() {
+ containerController.dispose()
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+import javax.inject.Inject
+
+class GetContainerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(x: Int, y: Int, z: Int): Container? {
+ return containerController.getContainer(x, y, z)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerAddedListener
+import javax.inject.Inject
+
+class RemoveContainerAddedListenerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(containerAddedListener: ContainerAddedListener) {
+ containerController.removeContainerAddedListener(containerAddedListener)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.listener.ContainerRemovedListener
+import javax.inject.Inject
+
+class RemoveContainerRemovedListenerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(containerRemovedListener: ContainerRemovedListener) {
+ containerController.removeContainerRemovedListener(containerRemovedListener)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import javax.inject.Inject
+
+class ResetContainerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(x: Int, y: Int, z: Int) {
+ containerController.resetContainer(x, y, z)
+ }
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.container.usecase
+
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import javax.inject.Inject
+
+class UpdateContainerControllerUseCase @Inject constructor(
+ private val containerController: ContainerController,
+) {
+
+ operator fun invoke(delta: Float) {
+ containerController.update(delta)
+ }
+
+}
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:items")
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop
+
+import ru.fredboy.cavedroid.game.controller.drop.listener.DropAddedListener
+import ru.fredboy.cavedroid.game.controller.drop.listener.DropRemovedListener
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+
+interface DropController {
+
+ val size: Int
+
+ fun getAllDrop(): Collection<Drop>
+
+ fun addDrop(drop: Drop)
+
+ fun addDrop(x: Float, y: Float, item: Item, count: Int)
+
+ fun addDrop(x: Float, y: Float, inventoryItem: InventoryItem)
+
+ fun forEach(action: (Drop) -> Unit)
+
+ fun update(delta: Float)
+
+ fun addDropAddedListener(listener: DropAddedListener)
+
+ fun removeDropAddedListener(listener: DropAddedListener)
+
+ fun addDropRemovedListener(listener: DropRemovedListener)
+
+ fun removeDropRemovedListener(listener: DropRemovedListener)
+
+ fun dispose()
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.impl.DropControllerImpl
+
+@Module
+abstract class ControllerDropModule {
+
+ @Binds
+ internal abstract fun bindDropController(impl: DropControllerImpl): DropController
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.impl
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.listener.DropAddedListener
+import ru.fredboy.cavedroid.game.controller.drop.listener.DropRemovedListener
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import java.util.LinkedList
+import javax.inject.Inject
+
+@GameScope
+class DropControllerImpl @Inject constructor() : DropController {
+
+ private val drops = LinkedList<Drop>()
+
+ private val dropAddedListeners = HashSet<DropAddedListener>()
+ private val dropRemovedListeners = HashSet<DropRemovedListener>()
+
+ constructor(initialDrop: Collection<Drop>) : this() {
+ drops.addAll(initialDrop)
+ }
+
+ override val size get() = drops.size
+
+ override fun getAllDrop(): Collection<Drop> {
+ return drops
+ }
+
+ override fun addDrop(drop: Drop) {
+ drops.add(drop)
+ dropAddedListeners.forEach { listener ->
+ listener.onDropAdded(drop)
+ }
+ }
+
+ override fun addDrop(x: Float, y: Float, item: Item, count: Int) {
+ addDrop(Drop(x, y, item, count))
+ }
+
+ override fun addDrop(x: Float, y: Float, inventoryItem: InventoryItem) {
+ addDrop(x, y, inventoryItem.item, inventoryItem.amount)
+ }
+
+ override fun forEach(action: (Drop) -> Unit) {
+ drops.forEach(action)
+ }
+
+ override fun update(delta: Float) {
+ val iterator = drops.iterator()
+
+ while (iterator.hasNext()) {
+ val drop = iterator.next();
+ if (drop.isPickedUp) {
+ iterator.remove()
+ dropRemovedListeners.forEach { listener ->
+ listener.onDropRemoved(drop)
+ }
+ }
+ }
+ }
+
+ override fun addDropAddedListener(listener: DropAddedListener) {
+ dropAddedListeners.add(listener)
+ }
+
+ override fun removeDropAddedListener(listener: DropAddedListener) {
+ dropAddedListeners.remove(listener)
+ }
+
+ override fun addDropRemovedListener(listener: DropRemovedListener) {
+ dropRemovedListeners.add(listener)
+ }
+
+ override fun removeDropRemovedListener(listener: DropRemovedListener) {
+ dropRemovedListeners.remove(listener)
+ }
+
+ override fun dispose() {
+ dropAddedListeners.clear()
+ dropAddedListeners.clear()
+ drops.clear()
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.listener
+
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+
+fun interface DropAddedListener {
+
+ fun onDropAdded(drop: Drop)
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.listener
+
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+
+fun interface DropRemovedListener {
+
+ fun onDropRemoved(drop: Drop)
+
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.model
+
+import com.badlogic.gdx.math.Intersector
+import com.badlogic.gdx.math.Rectangle
+import com.badlogic.gdx.math.Vector2
+import ru.fredboy.cavedroid.common.utils.BLOCK_SIZE_PX
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+
+class Drop(
+ x: Float,
+ y: Float,
+ val item: Item,
+ _amount: Int = 1,
+) : Rectangle(x, y, DROP_SIZE, DROP_SIZE) {
+
+ val velocity = getInitialVelocity()
+
+ var isPickedUp = false
+ var amount = _amount
+ private set
+
+ fun canMagnetTo(rectangle: Rectangle): Boolean {
+ val magnetArea = getMagnetArea()
+ return Intersector.overlaps(magnetArea, rectangle)
+ }
+
+ fun subtract(count: Int = 1) {
+ if (count < 0) {
+ throw IllegalArgumentException("Can't subtract negative amount")
+ }
+
+ amount -= count
+
+ if (amount <= 0) {
+ isPickedUp = true
+ }
+ }
+
+ private fun getMagnetArea(): Rectangle {
+ return Rectangle(
+ /* x = */ x - MAGNET_DISTANCE,
+ /* y = */ y - MAGNET_DISTANCE,
+ /* width = */ width + MAGNET_DISTANCE * 2,
+ /* height = */ height + MAGNET_DISTANCE * 2,
+ )
+ }
+
+
+ companion object {
+ private fun getInitialVelocity(): Vector2 = Vector2(0f, -1f)
+
+ private const val MAGNET_DISTANCE = 8f
+
+ const val MAGNET_VELOCITY = 256f
+ const val DROP_SIZE = BLOCK_SIZE_PX / 2
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.usecase
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import javax.inject.Inject
+
+@GameScope
+class AddDropUseCase @Inject constructor(
+ private val dropController: DropController,
+) {
+
+ operator fun invoke(drop: Drop) {
+ dropController.addDrop(drop)
+ }
+
+ operator fun invoke(x: Float, y: Float, item: Item, count: Int) {
+ dropController.addDrop(x, y, item, count)
+ }
+
+ operator fun invoke(x: Float, y: Float, inventoryItem: InventoryItem) {
+ dropController.addDrop(x, y, inventoryItem)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.usecase
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import javax.inject.Inject
+
+@GameScope
+class ForEachDropUseCase @Inject constructor(
+ private val dropController: DropController
+) {
+
+ operator fun invoke(action: (Drop) -> Unit) {
+ dropController.forEach(action)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.drop.usecase
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import javax.inject.Inject
+
+@GameScope
+class UpdateDropController @Inject constructor(
+ private val dropController: DropController
+) {
+
+ operator fun invoke(delta: Float) {
+ dropController.update(delta)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:assets")
+ useModule(":core:domain:items")
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob
+
+import ru.fredboy.cavedroid.game.controller.mob.model.Mob
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+
+interface MobController {
+
+ val mobs: List<Mob>
+
+ val player: Player
+
+ fun addMob(mob: Mob)
+
+ fun removeMob(mob: Mob)
+
+ operator fun plusAssign(mob: Mob) {
+ addMob(mob)
+ }
+
+ operator fun minusAssign(mob: Mob) {
+ removeMob(mob)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.impl.MobControllerImpl
+
+@Module
+abstract class MobControllerModule {
+
+ @Binds
+ internal abstract fun bindMobController(impl: MobControllerImpl): MobController
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.impl
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Mob
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import java.util.LinkedList
+import javax.inject.Inject
+
+@GameScope
+class MobControllerImpl @Inject constructor(
+ mobAssetsRepository: MobAssetsRepository,
+ getFallbackItemUseCase: GetFallbackItemUseCase,
+) : MobController {
+
+ private val _mobs = LinkedList<Mob>()
+
+ override val mobs: List<Mob> get() = _mobs
+
+ override var player = Player(mobAssetsRepository.getPlayerSprites(), getFallbackItemUseCase, 0f, 0f)
+
+ override fun addMob(mob: Mob) {
+ // TODO: Probably shouldn't add if already in the list
+ _mobs.add(mob)
+ }
+
+ override fun removeMob(mob: Mob) {
+ _mobs.remove(mob)
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.model
+
+import com.badlogic.gdx.math.MathUtils
+
+enum class Direction(
+ val index: Int,
+ val basis: Int,
+) {
+ LEFT(0, -1),
+ RIGHT(1, 1);
+
+ companion object {
+ fun random() = if (MathUtils.randomBoolean()) LEFT else RIGHT
+ }
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.model
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+
+class FallingBlock(
+ val block: Block,
+ x: Float,
+ y: Float,
+) : Mob(x, y, 1.px, 1.px, Direction.RIGHT, Int.MAX_VALUE , {}) {
+
+ init {
+ velocity.y = 1f
+ }
+
+ override val speed get() = 0f
+
+ override fun changeDir() = Unit
+
+ override fun jump() = Unit
+
+ override fun draw(
+ spriteBatch: SpriteBatch,
+ x: Float,
+ y: Float,
+ delta: Float
+ ) {
+ block.draw(spriteBatch, x, y)
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.model
+
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+
+class Inventory @JvmOverloads constructor(
+ val size: Int,
+ val hotbarSize: Int,
+ private val fallbackItem: Item.None,
+ initialItems: List<InventoryItem>? = null
+) {
+
+ private val _items: Array<InventoryItem>
+
+ init {
+ if (size < 0 || hotbarSize < 0 || hotbarSize > size) {
+ throw IllegalArgumentException("Invalid inventory sizes: hotbarSize=$hotbarSize; size=$size")
+ }
+
+ _items = Array(size) { index -> initialItems?.getOrNull(index) ?: fallbackItem.toInventoryItem() }
+ }
+
+ val items get() = _items.asList() as MutableList<InventoryItem>
+
+ val hotbarItems get() = items.subList(0, hotbarSize)
+
+ private var _activeSlot = 0
+
+ var activeSlot
+ get() = _activeSlot
+ set(value) {
+ if (value in 0 ..< hotbarSize) {
+ _activeSlot = value
+ }
+ }
+
+ val activeItem get() = _items[activeSlot]
+
+ fun getAvailableSlotForItem(item: Item): Int {
+ for (i in _items.indices) {
+ val inventoryItem = _items[i]
+
+ if (item == inventoryItem.item && inventoryItem.canBeAdded()) {
+ return i
+ }
+ }
+
+ for (i in _items.indices) {
+ val inventoryItem = _items[i]
+
+ if (inventoryItem.item.isNone()) {
+ return i
+ }
+ }
+
+ return -1
+ }
+
+ fun canPickItem(item: Item): Boolean {
+ return getAvailableSlotForItem(item) >= 0
+ }
+
+ fun addItem(item: Item) {
+ _items.copyInto(
+ destination = _items,
+ destinationOffset = 1,
+ startIndex = 0,
+ endIndex = size - 1
+ )
+
+ _items[0] = item.toInventoryItem(item.params.maxStack)
+ }
+
+ @JvmOverloads
+ fun decreaseItemAmount(slot: Int, count: Int = 1) {
+ val item = _items[slot]
+ item.subtract(count)
+ if (item.amount <= 0) {
+ _items[slot] = fallbackItem.toInventoryItem()
+ }
+ }
+
+ @JvmOverloads
+ fun decreaseCurrentItemAmount(count: Int = 1) {
+ decreaseItemAmount(activeSlot, count)
+ }
+
+ fun clear() {
+ for (i in _items.indices) {
+ _items[i] = fallbackItem.toInventoryItem()
+ }
+ }
+
+ companion object {
+ private const val SAVE_DATA_VERSION = 1
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.model
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.Color
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import com.badlogic.gdx.math.MathUtils
+import com.badlogic.gdx.math.Rectangle
+import com.badlogic.gdx.math.Vector2
+import com.badlogic.gdx.utils.Timer
+import ru.fredboy.cavedroid.common.utils.bl
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import kotlin.math.abs
+
+abstract class Mob(
+ x: Float,
+ y: Float,
+ width: Float,
+ height: Float,
+ var direction: Direction,
+ val maxHealth: Int,
+ val behaviourStrategy: Mob.(Float) -> Unit,
+) : Rectangle(x, y, width, height) {
+
+ private var resetTakeDamageTask: ResetTakeDamageTask? = null
+
+ var velocity = Vector2()
+ protected set
+
+ val mapX get() = (x + width / 2).bl
+ val upperMapY get() = y.bl
+ val middleMapY get() = (y + height / 2).bl
+ val lowerMapY get() = (y + height).bl
+
+ var animDelta = ANIMATION_SPEED;
+ var anim = 0f
+
+ var isDead = false
+ protected set
+
+ var canJump = false
+
+ var isFlyMode = false
+
+ var health = maxHealth
+
+ var takingDamage = false
+ set(value) {
+ field = value
+
+ if (value) {
+ var resetTask = resetTakeDamageTask
+ if (resetTask != null && resetTask.isScheduled) {
+ resetTask.cancel()
+ } else {
+ resetTask = ResetTakeDamageTask()
+ }
+ Timer.schedule(resetTask, DAMAGE_TINT_TIMEOUT_S)
+ resetTakeDamageTask = resetTask
+ }
+ }
+
+ protected val tintColor: Color
+ get() = if (takingDamage) {
+ DAMAGE_TINT_COLOR
+ } else {
+ Color.WHITE
+ }
+
+ abstract val speed: Float
+
+ private fun isAnimationIncreasing(): Boolean {
+ return anim > 0 && animDelta > 0 || anim < 0 && animDelta < 0
+ }
+
+ private fun checkHealth() {
+ health = MathUtils.clamp(health, 0, maxHealth)
+
+ if (health <= 0) {
+ kill()
+ }
+ }
+
+ protected fun updateAnimation(delta: Float) {
+ val velocityMultiplier = abs(velocity.x) / speed
+ val animMultiplier = (if (velocityMultiplier == 0f) 1f else velocityMultiplier) * delta
+ val maxAnim = ANIMATION_RANGE * (if (velocityMultiplier == 0f) 1f else velocityMultiplier)
+
+ if (velocity.x != 0f || abs(anim) > animDelta * animMultiplier) {
+ anim += animDelta * animMultiplier
+ } else {
+ anim = 0f
+ }
+
+ if (anim > maxAnim) {
+ anim = maxAnim
+ animDelta = -ANIMATION_SPEED
+ } else if (anim < -maxAnim) {
+ anim = -maxAnim
+ animDelta = ANIMATION_SPEED
+ }
+
+ if (velocity.x == 0f && isAnimationIncreasing()) {
+ animDelta = -animDelta
+ }
+ }
+
+ protected fun switchDir() {
+ direction = if (looksLeft()) {
+ Direction.RIGHT
+ } else {
+ Direction.LEFT
+ }
+ }
+
+ fun looksLeft() = direction == Direction.LEFT
+
+ fun looksRight() = direction == Direction.RIGHT
+
+ fun kill() {
+ isDead = true
+ }
+
+ open fun damage(damage: Int) {
+ if (damage == 0) {
+ return
+ }
+
+ if (damage < 0) {
+ Gdx.app.error(TAG, "Damage can't be negative!")
+ return
+ }
+
+ if (health <= Int.MIN_VALUE + damage) {
+ health = Int.MIN_VALUE + damage
+ }
+
+ health -= damage
+ checkHealth()
+
+ takingDamage = true
+ }
+
+ fun heal(heal: Int) {
+ if (heal < 0) {
+ Gdx.app.error(TAG, "Heal can't be negative")
+ return
+ }
+
+ if (health >= Int.MAX_VALUE - heal) {
+ health = Int.MAX_VALUE - heal
+ }
+
+ health += health
+ checkHealth()
+ }
+
+ fun getHitBox(): Rectangle {
+ return Rectangle(
+ /* x = */ x - HIT_RANGE,
+ /* y = */ y + HIT_RANGE,
+ /* width = */ width + HIT_RANGE * 2f,
+ /* height = */ height + HIT_RANGE * 2f
+ )
+ }
+
+ fun update(delta: Float) {
+ this.behaviourStrategy(delta)
+ }
+
+ open fun getDropItems(
+ itemByKey: GetItemByKeyUseCase
+ ): List<InventoryItem> {
+ return emptyList()
+ }
+
+ fun attachToController(mobController: MobController) {
+ mobController += this
+ }
+
+ abstract fun draw(spriteBatch: SpriteBatch, x: Float, y: Float, delta: Float)
+
+ abstract fun changeDir()
+
+ abstract fun jump()
+
+ private inner class ResetTakeDamageTask : Timer.Task() {
+ override fun run() {
+ takingDamage = false
+ }
+ }
+
+ companion object {
+ private const val TAG = "Mob"
+
+ @JvmStatic
+ protected val ANIMATION_SPEED = 360f
+
+ protected const val ANIMATION_RANGE = 60f
+
+ private const val HIT_RANGE = 8f;
+
+ private const val DAMAGE_TINT_TIMEOUT_S = 0.5f
+ private val DAMAGE_TINT_COLOR = Color((0xff8080 shl 8) or 0xFF)
+
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.model
+
+import com.badlogic.gdx.graphics.Color
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import com.badlogic.gdx.math.Vector2
+import ru.fredboy.cavedroid.common.utils.drawSprite
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+
+class Pig(
+ private val sprite: MobSprite.Pig,
+ x: Float,
+ y: Float
+) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, {}) {
+
+ override val speed get() = SPEED
+
+ override fun changeDir() {
+ switchDir()
+ velocity = Vector2(direction.basis * speed, 0f)
+ }
+
+ override fun jump() {
+ velocity.y = JUMP_VELOCITY
+ }
+
+ override fun damage(damage: Int) {
+ super.damage(damage)
+
+ if (damage > 0) {
+ if (canJump) {
+ jump()
+ }
+ }
+ }
+
+ override fun getDropItems(itemByKey: GetItemByKeyUseCase): List<InventoryItem> {
+ return listOf(itemByKey["porkchop_raw"].toInventoryItem())
+ }
+
+ override fun draw(
+ spriteBatch: SpriteBatch,
+ x: Float,
+ y: Float,
+ delta: Float
+ ) {
+ updateAnimation(delta)
+
+ val leftLegX = x + sprite.getLeftLegRelativeX(direction.index)
+ val rightLegX = x + sprite.getRightLegRelativeX(direction.index)
+ val legY = y + sprite.getLegsRelativeY()
+
+ 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)
+ }
+
+ companion object {
+ private const val WIDTH = 25f
+ private const val HEIGHT = 18f
+ private const val SPEED = 48f
+ private const val JUMP_VELOCITY = -133.332f
+ private const val MAX_HEALTH = 10
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.model
+
+import com.badlogic.gdx.graphics.Color
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import com.badlogic.gdx.math.MathUtils
+import com.badlogic.gdx.math.Vector2
+import ru.fredboy.cavedroid.common.utils.applyOrigin
+import ru.fredboy.cavedroid.common.utils.drawSprite
+import ru.fredboy.cavedroid.domain.assets.model.MobSprite
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+
+class Player(
+ private val sprite: MobSprite.Player,
+ private val getFallbackItem: GetFallbackItemUseCase,
+ x: Float,
+ y: Float,
+) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, {}) {
+
+ var inventory = Inventory(
+ size = INVENTORY_SIZE,
+ hotbarSize = HOTBAR_SIZE,
+ fallbackItem = getFallbackItem(),
+ )
+
+ var gameMode = 0
+ var swim = false
+
+ var cursorX = 0
+ var cursorY = 0
+
+ var controlMode = ControlMode.WALK
+ var blockDamage = 0f
+
+ var isHitting = false
+ var isHittingWithDamage = false
+
+ var hitAnim = 0f
+ var hitAnimDelta = ANIMATION_SPEED
+
+ var headRotation = 0f
+
+ override val speed get() = SPEED
+
+ override fun changeDir() {
+ switchDir()
+ velocity = Vector2(direction.basis * speed, 0f)
+ }
+
+ override fun jump() {
+ velocity.y = JUMP_VELOCITY
+ }
+
+ override fun damage(damage: Int) {
+ super.damage(damage)
+
+ if (damage > 0 && canJump) {
+ jump()
+ }
+ }
+
+ override fun getDropItems(itemByKey: GetItemByKeyUseCase): List<InventoryItem> {
+ return inventory.items
+ }
+
+ override fun draw(spriteBatch: SpriteBatch, x: Float, y: Float, delta: Float) {
+ with(sprite) {
+ hand.setFlip(looksRight(), hand.isFlipY)
+ leg.setFlip(looksRight(), leg.isFlipY)
+ head.setFlip(looksRight(), head.isFlipY)
+ body.setFlip(looksRight(), body.isFlipY)
+
+ hand.setOrigin(hand.width / 2f, 0f)
+ leg.setOrigin(leg.width / 2f, 0f)
+ head.setOrigin(head.width / 2, head.height)
+
+ var backHandAnim = 0f
+ var frontHandAnim = 0f
+
+ val rightHandAnim = getRightHandAnim(delta)
+
+ if (looksLeft()) {
+ backHandAnim = rightHandAnim
+ frontHandAnim = anim
+ } else {
+ backHandAnim = -anim
+ frontHandAnim = -rightHandAnim
+ }
+
+ val backgroundTintColor = tintColor.cpy().sub(Color(0xAAAAAA shl 16))
+
+ hand.color = backgroundTintColor
+ spriteBatch.drawSprite(hand, x + getBodyRelativeX(), y + getBodyRelativeY(), backHandAnim)
+
+ if (looksLeft()) {
+ drawItem(spriteBatch, x, y, -backHandAnim)
+ }
+
+ leg.color = backgroundTintColor
+ spriteBatch.drawSprite(leg, x + getBodyRelativeX(), y + getLegsRelativeY(), anim)
+
+ leg.color = tintColor
+ spriteBatch.drawSprite(leg, x + getBodyRelativeX(), y + getLegsRelativeY(), -anim)
+
+ head.color = tintColor
+ spriteBatch.drawSprite(head, x, y, headRotation)
+
+ body.color = tintColor
+ spriteBatch.drawSprite(body, x + getBodyRelativeX(), y + getBodyRelativeY())
+
+ if (looksRight()) {
+ drawItem(spriteBatch, x, y, frontHandAnim)
+ }
+
+ hand.color = tintColor
+ spriteBatch.drawSprite(hand, x + getBodyRelativeX(), y + getBodyRelativeY(), frontHandAnim)
+ }
+ }
+
+ fun startHitting(withDamage: Boolean = true) {
+ if (isHitting) {
+ return
+ }
+
+ isHitting = true
+ isHittingWithDamage = withDamage
+ hitAnim = HIT_ANIMATION_RANGE.endInclusive
+ hitAnimDelta = ANIMATION_SPEED
+ }
+
+ fun stopHitting() {
+ blockDamage = 0f
+ isHitting = false
+ }
+
+ fun decreaseCurrentItemCount() {
+ if (gameMode == 1) {
+ return
+ }
+
+ inventory.activeItem.subtract()
+
+ if (inventory.activeItem.amount <= 0) {
+ setCurrentInventorySlotItem(getFallbackItem())
+ }
+ }
+
+ fun setCurrentInventorySlotItem(item: Item) {
+ inventory.items[inventory.activeSlot] = item.toInventoryItem()
+ }
+
+ private fun drawItem(spriteBatch: SpriteBatch, x: Float, y: Float, handAnim: Float) {
+ val item = inventory.activeItem.item.takeIf { !it.isNone() } ?: return
+ val itemSprite = item.sprite
+ val isSmallSprite = !item.isTool() || item.isShears()
+ val originalWidth = itemSprite.width
+ val originalHeight = itemSprite.height
+ val handLength = sprite.hand.height
+
+ if (isSmallSprite) {
+ itemSprite.setSize(SMALL_ITEM_SIZE, SMALL_ITEM_SIZE)
+ }
+
+ val spriteOrigin = item.params.inHandSpriteOrigin
+ val handMultiplier = -direction.basis
+ val xOffset = (-1 + direction.index) * itemSprite.width + SMALL_ITEM_SIZE / 2 +
+ handMultiplier * itemSprite.width * spriteOrigin.x
+ val yOffset = if (!isSmallSprite) - itemSprite.height / 2 else 0f
+
+ val rotate = handAnim + HAND_ITEM_ANGLE_DEG
+
+ if (item.isTool()) {
+ itemSprite.rotate90(looksLeft())
+ }
+
+ val itemX = x + handLength * MathUtils.sin(handMultiplier * handAnim * MathUtils.degRad) + xOffset
+ val itemY = y + handLength * MathUtils.cos(handMultiplier * handAnim * MathUtils.degRad) + yOffset
+
+ if (looksLeft()) {
+ itemSprite.setFlip(!item.isTool(), itemSprite.isFlipY)
+ itemSprite.applyOrigin(spriteOrigin.getFlipped(flipX = true, flipY = false))
+ } else {
+ itemSprite.setFlip(item.isTool(), itemSprite.isFlipY)
+ itemSprite.applyOrigin(spriteOrigin)
+ }
+
+ itemSprite.rotation = -handMultiplier * rotate
+ itemSprite.setPosition(itemX, itemY)
+ itemSprite.draw(spriteBatch)
+
+
+ // dont forget to reset
+ itemSprite.setFlip(false, itemSprite.isFlipY)
+ itemSprite.rotation = 0f
+ itemSprite.setOriginCenter()
+ itemSprite.setSize(originalWidth, originalHeight)
+ if (item.isTool()) {
+ itemSprite.rotate90(looksRight())
+ }
+ }
+
+ private fun getRightHandAnim(delta: Float): Float {
+ hitAnim -= hitAnimDelta * delta
+
+ if (hitAnim !in HIT_ANIMATION_RANGE) {
+ if (isHitting) {
+ hitAnim = MathUtils.clamp(hitAnim, HIT_ANIMATION_RANGE.start, HIT_ANIMATION_RANGE.endInclusive)
+ hitAnimDelta = -hitAnimDelta
+ } else {
+ hitAnimDelta = ANIMATION_SPEED
+ }
+ }
+
+ if (!isHitting) {
+ if (hitAnim < hitAnimDelta * delta) {
+ hitAnim = 0f
+ hitAnimDelta = 0f
+ return -anim
+ }
+ }
+
+ return hitAnim
+ }
+
+ enum class ControlMode {
+ WALK,
+ CURSOR
+ }
+
+ companion object {
+ const val HOTBAR_SIZE = 9
+ const val INVENTORY_SIZE = 36
+
+ const val MAX_HEALTH = 20
+
+ private const val WIDTH = 4f
+ private const val HEIGHT = 30f
+
+ private const val SPEED = 69.072f
+ private const val JUMP_VELOCITY = -133.332f
+
+ private val HIT_ANIMATION_RANGE = 30f..90f
+
+ private val SMALL_ITEM_SIZE = 8f
+ private val HAND_ITEM_ANGLE_DEG = 30f
+ }
+}
\ No newline at end of file
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:items")
+
+ useModule(":core:game:controller:container")
+ useModule(":core:game:controller:drop")
+ useModule(":core:game:controller:mob")
+}
--- /dev/null
+package ru.fredboy.cavedroid.game.world
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.math.MathUtils
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.container.model.Chest
+import ru.fredboy.cavedroid.game.controller.container.model.Container
+import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import ru.fredboy.cavedroid.game.world.generator.GameWorldGenerator
+import ru.fredboy.cavedroid.game.world.generator.WorldGeneratorConfig
+import javax.inject.Inject
+
+@GameScope
+class GameWorld @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+ private val containerController: ContainerController,
+ private val mobController: MobController,
+ private val dropController: DropController,
+ initialForeMap: Array<Array<Block>>?,
+ initialBackMap: Array<Array<Block>>?,
+) {
+ val foreMap: Array<Array<Block>>
+ val backMap: Array<Array<Block>>
+
+ val width: Int
+ val height: Int
+
+ val generatorConfig = WorldGeneratorConfig.getDefault()
+
+ init {
+ width = generatorConfig.width
+ height = generatorConfig.height
+
+ val (generatedFore, generatedBack) = GameWorldGenerator(generatorConfig, itemsRepository).generate()
+ foreMap = generatedFore
+ backMap = generatedBack
+ }
+
+ private fun transformX(x: Int): Int {
+ var transformed = x % width
+ if (transformed < 0) {
+ transformed = width + x
+ }
+ return transformed
+ }
+
+ private fun getMap(x: Int, y: Int, layer: Int): Block {
+ val fallback = itemsRepository.fallbackBlock
+
+ if (y !in 0 ..< height) {
+ return fallback
+ }
+
+ val transformedX = transformX(x)
+
+ if (transformedX !in 0 ..< width) {
+ return fallback
+ }
+
+ return when (layer) {
+ FOREGROUND_Z -> foreMap[transformedX][y]
+ BACKGROUND_Z -> backMap[transformedX][y]
+ else -> {
+ Gdx.app.error(TAG, "Unexpected value for layer in getMap ($layer). Returning fallback")
+ fallback
+ }
+ }
+ }
+
+ private fun setMap(x: Int, y: Int, layer: Int, value: Block) {
+ if (y !in 0 ..< height) {
+ return
+ }
+
+ val transformedX = transformX(x)
+
+ if (transformedX !in 0 ..< width) {
+ return
+ }
+
+ containerController.destroyContainer(x, y, layer)
+
+ if (value.isContainer()) {
+ when {
+ value.isChest() -> Chest(itemsRepository.fallbackItem)
+ value.isFurnace() -> Furnace(itemsRepository.fallbackItem)
+ else -> {
+ Gdx.app.error(TAG, "Unknow container type: ${value::class.simpleName}")
+ null
+ }
+ }?.let { container ->
+ containerController.addContainer(x, y, layer, container)
+ }
+ }
+
+ when (layer) {
+ FOREGROUND_Z -> foreMap[transformedX][y] = value
+ BACKGROUND_Z -> backMap[transformedX][y] = value
+ else -> {
+ Gdx.app.error(TAG, "Unexpected value for layer in setMap ($layer). Returning fallback")
+ }
+ }
+ }
+
+ private fun isSameSlab(slab1: Block, slab2: Block): Boolean {
+ return slab1 is Block.Slab && slab2 is Block.Slab &&
+ (slab1.params.key == slab2.otherPartBlockKey || slab1.otherPartBlockKey == slab2.params.key)
+ }
+
+ fun hasForeAt(x: Int, y: Int): Boolean {
+ return !getMap(x, y, FOREGROUND_Z).isNone()
+ }
+
+ fun hasBackAt(x: Int, y: Int): Boolean {
+ return !getMap(x, y, BACKGROUND_Z).isNone()
+ }
+
+ fun getForeMap(x: Int, y: Int): Block {
+ return getMap(x, y, FOREGROUND_Z)
+ }
+
+ fun setForeMap(x: Int, y: Int, block: Block) {
+ setMap(x, y, FOREGROUND_Z, block)
+ }
+
+ fun resetForeMap(x: Int, y: Int) {
+ setForeMap(x, y, itemsRepository.fallbackBlock)
+ }
+
+ fun getBackMap(x: Int, y: Int): Block {
+ return getMap(x, y, BACKGROUND_Z)
+ }
+
+ fun setBackMap(x: Int, y: Int, block: Block) {
+ setMap(x, y, BACKGROUND_Z, block)
+ }
+
+ fun canPlaceToForeground(x: Int, y: Int, value: Block): Boolean {
+ return !hasForeAt(x, y) || value.isNone() || !getForeMap(x, y).params.hasCollision
+ }
+
+ fun placeToForeground(x: Int, y: Int, value: Block): Boolean {
+ return if (canPlaceToForeground(x, y, value)) {
+ setForeMap(x, y, value)
+ true
+ } else if (value is Block.Slab && isSameSlab(value, getForeMap(x, y))) {
+ setForeMap(x, y, itemsRepository.getBlockByKey(value.otherPartBlockKey))
+ true
+ } else {
+ false
+ }
+ }
+
+ fun placeToBackground(x: Int, y: Int, value: Block): Boolean {
+ return if (value.isNone() || getBackMap(x, y).isNone() && value.params.hasCollision &&
+ (!value.params.isTransparent || value.params.key == "glass" || value.isChest() || value.isSlab())) {
+ setBackMap(x, y, value)
+ true
+ } else {
+ false
+ }
+ }
+
+ fun checkPlayerCursorBounds() {
+ with(mobController.player) {
+ if (gameMode == 0) {
+ val minCursorX = mapX - SURVIVAL_CURSOR_RANGE
+ val maxCursorX = mapX + SURVIVAL_CURSOR_RANGE
+ val minCursorY = middleMapY - SURVIVAL_CURSOR_RANGE
+ val maxCursorY = middleMapY + SURVIVAL_CURSOR_RANGE
+
+ cursorX = MathUtils.clamp(cursorX, minCursorX, maxCursorX)
+ cursorY = MathUtils.clamp(cursorY, minCursorY, maxCursorY)
+ }
+
+ cursorY = MathUtils.clamp(cursorY, 0, this@GameWorld.height)
+ }
+ }
+
+ fun playerDurateTool() {
+ TODO()
+ }
+
+ private fun shouldDrop(block: Block): Boolean {
+ TODO()
+ }
+
+ private fun spawnInitialMobs() {
+ TODO()
+ }
+
+ fun destroyForeMap(x: Int, y: Int) {
+ val block = getForeMap(x, y)
+
+ if (block.isContainer()) {
+ containerController.destroyContainer(x, y, FOREGROUND_Z)
+ }
+
+ block.params.dropInfo?.takeIf { shouldDrop(block) }?.let { dropInfo ->
+ dropController.addDrop(
+ x = transformX(x).px,
+ y = y.px,
+ item = itemsRepository.getItemByKey(dropInfo.itemKey),
+ count = dropInfo.count,
+ )
+ }
+ playerDurateTool()
+ placeToForeground(x, y, itemsRepository.fallbackBlock)
+ }
+
+ fun destroyBackMap(x: Int, y: Int) {
+ val block = getBackMap(x, y)
+
+ if (block.isContainer()) {
+ containerController.destroyContainer(x, y, BACKGROUND_Z)
+ }
+
+ block.params.dropInfo?.takeIf { shouldDrop(block) }?.let { dropInfo ->
+ dropController.addDrop(
+ x = transformX(x).px,
+ y = y.px,
+ item = itemsRepository.getItemByKey(dropInfo.itemKey),
+ count = dropInfo.count,
+ )
+ }
+ playerDurateTool()
+ placeToBackground(x, y, itemsRepository.fallbackBlock)
+ }
+
+ private fun getContainerAt(x: Int, y: Int, layer: Int): Container? {
+ return containerController.getContainer(x, y, layer)
+ }
+
+ fun getForegroundContainer(x: Int, y: Int): Container? {
+ return getContainerAt(x, y, FOREGROUND_Z)
+ }
+
+ fun getBackgroundContainer(x: Int, y: Int): Container? {
+ return getContainerAt(x, y, BACKGROUND_Z)
+ }
+
+ fun getForegroundFurnace(x: Int, y: Int): Furnace? {
+ return getForegroundContainer(x, y) as? Furnace
+ }
+
+ fun getBackgroundFurnace(x: Int, y: Int): Furnace? {
+ return getBackgroundContainer(x, y) as? Furnace
+ }
+
+
+ companion object {
+ private const val TAG = "GameWorld"
+
+ private const val FOREGROUND_Z = 0
+ private const val BACKGROUND_Z = 1
+
+ private const val SURVIVAL_CURSOR_RANGE = 4
+ }
+}
\ No newline at end of file
-package ru.deadsoftware.cavedroid.game.model.world
+package ru.fredboy.cavedroid.game.world.generator
enum class Biome {
PLAINS,
-package ru.deadsoftware.cavedroid.game.world
+package ru.fredboy.cavedroid.game.world.generator
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.model.world.Biome
-import ru.deadsoftware.cavedroid.game.model.world.generator.WorldGeneratorConfig
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
class GameWorldGenerator(
private val config: WorldGeneratorConfig,
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
) {
private val random = Random(config.seed)
- private val foreMap by lazy { Array(config.width) { Array(config.height) { gameItemsHolder.fallbackBlock } } }
- private val backMap by lazy { Array(config.width) { Array(config.height) { gameItemsHolder.fallbackBlock } } }
+ private val foreMap by lazy { Array(config.width) { Array<Block>(config.height) { itemsRepository.fallbackBlock } } }
+ private val backMap by lazy { Array(config.width) { Array<Block>(config.height) { itemsRepository.fallbackBlock } } }
private val heights by lazy { generateHeights() }
private val biomesMap by lazy { generateBiomes() }
val surfaceHeight = heights[x]
- val grass = gameItemsHolder.getBlock("grass_snowed")
- val bedrock = gameItemsHolder.getBlock("bedrock")
- val dirt = gameItemsHolder.getBlock("dirt")
- val stone = gameItemsHolder.getBlock("stone")
- val snow = gameItemsHolder.getBlock("snow")
+ val grass = itemsRepository.getBlockByKey("grass_snowed")
+ val bedrock = itemsRepository.getBlockByKey("bedrock")
+ val dirt = itemsRepository.getBlockByKey("dirt")
+ val stone = itemsRepository.getBlockByKey("stone")
+ val snow = itemsRepository.getBlockByKey("snow")
foreMap[x][surfaceHeight] = grass
foreMap[x][config.height - 1] = bedrock
val surfaceHeight = heights[x]
- val grass = gameItemsHolder.getBlock("grass")
- val bedrock = gameItemsHolder.getBlock("bedrock")
- val dirt = gameItemsHolder.getBlock("dirt")
- val stone = gameItemsHolder.getBlock("stone")
+ val grass = itemsRepository.getBlockByKey("grass")
+ val bedrock = itemsRepository.getBlockByKey("bedrock")
+ val dirt = itemsRepository.getBlockByKey("dirt")
+ val stone = itemsRepository.getBlockByKey("stone")
foreMap[x][surfaceHeight] = grass
foreMap[x][config.height - 1] = bedrock
val surfaceHeight = heights[x]
- val sand = gameItemsHolder.getBlock("sand")
- val bedrock = gameItemsHolder.getBlock("bedrock")
- val sandstone = gameItemsHolder.getBlock("sandstone")
- val stone = gameItemsHolder.getBlock("stone")
+ val sand = itemsRepository.getBlockByKey("sand")
+ val bedrock = itemsRepository.getBlockByKey("bedrock")
+ val sandstone = itemsRepository.getBlockByKey("sandstone")
+ val stone = itemsRepository.getBlockByKey("stone")
foreMap[x][surfaceHeight] = sand
}
private fun fillWater() {
- val water = gameItemsHolder.getBlock("water")
+ val water = itemsRepository.getBlockByKey("water")
for (x in 0 ..< config.width) {
for (y in config.seaLevel ..< config.height) {
- if (foreMap[x][y] != gameItemsHolder.fallbackBlock) {
+ if (!foreMap[x][y].isNone()) {
break
}
}
private fun generateCactus(x: Int) {
- val cactus = gameItemsHolder.getBlock("cactus")
+ val cactus = itemsRepository.getBlockByKey("cactus")
val cactusHeight = random.nextInt(3)
val h = heights[x] - 1
}
private fun generateOak(x: Int) {
- val log = gameItemsHolder.getBlock("log_oak")
- val leaves = gameItemsHolder.getBlock("leaves_oak")
+ val log = itemsRepository.getBlockByKey("log_oak")
+ val leaves = itemsRepository.getBlockByKey("leaves_oak")
val h = heights[x] - 1
val treeH = random.nextInt(5, 7)
val height = max(0, h - treeH)
backMap[x1][y] = leaves
}
if (random.nextInt(15) < 3) {
- foreMap[x1][heights[x1] - 1] = gameItemsHolder.getBlock(mushrooms.random(random))
+ foreMap[x1][heights[x1] - 1] = itemsRepository.getBlockByKey(mushrooms.random(random))
}
}
}
private fun generateSpruce(x: Int) {
- val log = gameItemsHolder.getBlock("log_spruce")
- val leaves = gameItemsHolder.getBlock("leaves_spruce")
+ val log = itemsRepository.getBlockByKey("log_spruce")
+ val leaves = itemsRepository.getBlockByKey("leaves_spruce")
val h = heights[x] - 1
val treeH = random.nextInt(7, 9)
val height = max(0, h - treeH)
}
private fun generateTallGrass(x: Int) {
- val tallGrass = gameItemsHolder.getBlock(plainsPlants.random(random))
+ val tallGrass = itemsRepository.getBlockByKey(plainsPlants.random(random))
val h = heights[x] - 1
if (h > 0) {
foreMap[x][h] = tallGrass
}
private fun generateDeadBush(x: Int) {
- val bush = gameItemsHolder.getBlock("deadbush")
+ val bush = itemsRepository.getBlockByKey("deadbush")
val h = heights[x] - 1
if (h > 0) {
foreMap[x][h] = bush
}
private fun generateOres(x : Int) {
- val stone = gameItemsHolder.getBlock("stone")
- val coal = gameItemsHolder.getBlock("coal_ore")
- val iron = gameItemsHolder.getBlock("iron_ore")
- val gold = gameItemsHolder.getBlock("gold_ore")
- val diamond = gameItemsHolder.getBlock("diamond_ore")
- val lapis = gameItemsHolder.getBlock("lapis_ore")
+ val stone = itemsRepository.getBlockByKey("stone")
+ val coal = itemsRepository.getBlockByKey("coal_ore")
+ val iron = itemsRepository.getBlockByKey("iron_ore")
+ val gold = itemsRepository.getBlockByKey("gold_ore")
+ val diamond = itemsRepository.getBlockByKey("diamond_ore")
+ val lapis = itemsRepository.getBlockByKey("lapis_ore")
for (y in heights[x] ..< config.height) {
val res = random.nextInt(10000)
-package ru.deadsoftware.cavedroid.game.model.world.generator
+package ru.fredboy.cavedroid.game.world.generator
import com.badlogic.gdx.utils.TimeUtils
-import ru.deadsoftware.cavedroid.game.model.world.Biome
data class WorldGeneratorConfig(
val width: Int,
import dagger.Component;
import ru.deadsoftware.cavedroid.MainComponent;
import ru.deadsoftware.cavedroid.generated.module.*;
+import ru.fredboy.cavedroid.common.di.GameScope;
+import ru.fredboy.cavedroid.data.assets.di.DataAssetsModule;
+import ru.fredboy.cavedroid.data.items.di.DataItemsModule;
+import ru.fredboy.cavedroid.data.save.di.DataSaveModule;
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository;
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository;
@GameScope
@Component(dependencies = {
MainComponent.class
},
modules = {GameModule.class,
+// DataAssetsModule.class,
+// DataItemsModule.class,
+ DataSaveModule.class,
UseItemActionsModule.class,
UpdateBlockActionsModule.class,
PlaceBlockActionsModule.class,
public interface GameComponent {
GameProc getGameProc();
- GameItemsHolder getGameItemsHolder();
+ ItemsRepository getItemsRepository();
}
import dagger.Provides;
import org.jetbrains.annotations.Nullable;
import ru.deadsoftware.cavedroid.MainConfig;
-import ru.deadsoftware.cavedroid.game.mobs.MobsController;
-import ru.deadsoftware.cavedroid.game.model.block.Block;
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
-import ru.deadsoftware.cavedroid.game.objects.container.ContainerController;
-import ru.deadsoftware.cavedroid.game.save.GameSaveData;
-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.common.di.GameScope;
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository;
import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase;
import ru.fredboy.cavedroid.domain.assets.usecase.GetPlayerSpritesUseCase;
+import ru.fredboy.cavedroid.domain.items.model.block.Block;
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository;
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase;
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase;
+import ru.fredboy.cavedroid.domain.save.model.GameSaveData;
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository;
+import ru.fredboy.cavedroid.game.controller.container.ContainerController;
+import ru.fredboy.cavedroid.game.controller.container.impl.ContainerControllerImpl;
+import ru.fredboy.cavedroid.game.controller.drop.DropController;
+import ru.fredboy.cavedroid.game.controller.drop.impl.DropControllerImpl;
+import ru.fredboy.cavedroid.game.controller.mob.MobController;
+import ru.fredboy.cavedroid.game.controller.mob.impl.MobControllerImpl;
+import ru.fredboy.cavedroid.game.world.GameWorld;
@Module
public class GameModule {
public static boolean loaded = false;
- private static void load(MainConfig mainConfig,
- GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager,
- GetPlayerSpritesUseCase getPlayerSpritesUseCase,
- GetPigSpritesUseCase getPigSpritesUseCase) {
+ private static void load(MainConfig mainConfig, SaveDataRepository saveDataRepository) {
if (loaded) {
return;
}
- data = GameSaveLoader.INSTANCE.load(mainConfig,
- gameItemsHolder,
- tooltipManager,
- getPlayerSpritesUseCase,
- getPigSpritesUseCase);
+ data = saveDataRepository.load(mainConfig.getGameFolder());
loaded = true;
}
@Provides
@GameScope
public static DropController provideDropController(MainConfig mainConfig,
- GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager,
- GetPlayerSpritesUseCase getPlayerSpritesUseCase,
- GetPigSpritesUseCase getPigSpritesUseCase) {
- load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
- DropController controller = data != null ? data.retrieveDropController() : new DropController();
+ SaveDataRepository saveDataRepository) {
+ load(mainConfig, saveDataRepository);
+ DropController controller = data != null ? data.retrieveDropController() : new DropControllerImpl();
makeDataNullIfEmpty();
- controller.initDrops(gameItemsHolder);
return controller;
}
@Provides
@GameScope
public static ContainerController provideFurnaceController(MainConfig mainConfig,
- DropController dropController,
- GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager,
- GetPlayerSpritesUseCase getPlayerSpritesUseCase,
- GetPigSpritesUseCase getPigSpritesUseCase) {
- load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
+ SaveDataRepository saveDataRepository,
+ GetItemByKeyUseCase getItemByKeyUseCase
+ ) {
+ load(mainConfig, saveDataRepository);
ContainerController controller = data != null
? data.retrieveContainerController()
- : new ContainerController(dropController, gameItemsHolder);
+ : new ContainerControllerImpl(getItemByKeyUseCase);
makeDataNullIfEmpty();
- controller.init(dropController, gameItemsHolder);
return controller;
}
@Provides
@GameScope
- public static MobsController provideMobsController(MainConfig mainConfig,
- GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager,
- GetPlayerSpritesUseCase getPlayerSpritesUseCase,
- GetPigSpritesUseCase getPigSpritesUseCase) {
- load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
- MobsController controller = data != null
+ public static MobController provideMobsController(MainConfig mainConfig,
+ SaveDataRepository saveDataRepository,
+ MobAssetsRepository mobAssetsRepository,
+ GetFallbackItemUseCase getFallbackItemUseCase) {
+ load(mainConfig, saveDataRepository);
+ MobController controller = data != null
? data.retrieveMobsController()
- : new MobsController(gameItemsHolder, tooltipManager, getPlayerSpritesUseCase);
+ : new MobControllerImpl(mobAssetsRepository, getFallbackItemUseCase);
makeDataNullIfEmpty();
- controller.getPlayer().initInventory(gameItemsHolder, tooltipManager);
return controller;
}
@Provides
@GameScope
public static GameWorld provideGameWorld(MainConfig mainConfig,
- DropController dropController,
- MobsController mobsController,
- GameItemsHolder gameItemsHolder,
+ SaveDataRepository saveDataRepository,
+ ItemsRepository itemsRepository,
ContainerController containerController,
- TooltipManager tooltipManager,
- GetPlayerSpritesUseCase getPlayerSpritesUseCase,
- GetPigSpritesUseCase getPigSpritesUseCase) {
- load(mainConfig, gameItemsHolder, tooltipManager, getPlayerSpritesUseCase, getPigSpritesUseCase);
+ MobController mobController,
+ DropController dropController
+ ) {
+ load(mainConfig, saveDataRepository);
Block[][] fm = data != null ? data.retrieveForeMap() : null;
Block[][] bm = data != null ? data.retrieveBackMap() : null;
makeDataNullIfEmpty();
- return new GameWorld(dropController, mobsController, gameItemsHolder, containerController, fm, bm);
+ return new GameWorld(itemsRepository, containerController, mobController, dropController, fm, bm);
}
}
import com.badlogic.gdx.math.Vector2;
import org.jetbrains.annotations.Nullable;
import ru.deadsoftware.cavedroid.MainConfig;
-import ru.deadsoftware.cavedroid.game.mobs.Mob;
-import ru.deadsoftware.cavedroid.game.mobs.MobsController;
-import ru.deadsoftware.cavedroid.game.mobs.player.Player;
-import ru.deadsoftware.cavedroid.game.model.block.Block;
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
-import ru.deadsoftware.cavedroid.game.objects.drop.Drop;
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
-import ru.deadsoftware.cavedroid.game.world.GameWorld;
+import ru.fredboy.cavedroid.common.di.GameScope;
+import ru.fredboy.cavedroid.common.utils.MeasureUnitsUtilsKt;
+import ru.fredboy.cavedroid.domain.items.model.block.Block;
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem;
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase;
+import ru.fredboy.cavedroid.game.controller.drop.DropController;
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop;
+import ru.fredboy.cavedroid.game.controller.mob.MobController;
+import ru.fredboy.cavedroid.game.controller.mob.model.FallingBlock;
+import ru.fredboy.cavedroid.game.controller.mob.model.Mob;
+import ru.fredboy.cavedroid.game.controller.mob.model.Player;
+import ru.fredboy.cavedroid.game.world.GameWorld;
import javax.inject.Inject;
import java.util.Iterator;
-
@GameScope
public class GamePhysics {
private final GameWorld mGameWorld;
private final MainConfig mMainConfig;
- private final MobsController mMobsController;
+ private final MobController mMobController;
private final DropController mDropController;
- private final GameItemsHolder mGameItemsHolder;
+ private final GetItemByKeyUseCase mGetItemByKeyUseCase;
@Inject
public GamePhysics(GameWorld gameWorld,
MainConfig mainConfig,
- MobsController mobsController,
+ MobController mobController,
DropController dropController,
- GameItemsHolder gameItemsHolder) {
+ GetItemByKeyUseCase getItemByKeyUseCase) {
mGameWorld = gameWorld;
mMainConfig = mainConfig;
- mMobsController = mobsController;
+ mMobController = mobController;
mDropController = dropController;
- mGameItemsHolder = gameItemsHolder;
+ mGetItemByKeyUseCase = getItemByKeyUseCase;
}
/**
return false;
}
- return (block.toJump() &&
+ return (block.getParams().getHasCollision() && block.getParams().getCollisionMargins().getTop() < 8 &&
(mob.getY() + mob.getHeight()) - block.getRectangle(blX / 16, blY / 16).y > 8);
}
continue;
}
block = mGameWorld.getForeMap(x, y);
- if (block.hasCollision()) {
+ if (block.getParams().getHasCollision()) {
final Rectangle blockRect = block.getRectangle(x, y);
if (Intersector.overlaps(rect, blockRect)) {
return blockRect;
return null;
}
+ private boolean isBlockToJump(Block block) {
+ return block.getParams().getHasCollision() && block.getParams().getCollisionMargins().getTop() < 8;
+ }
+
private Block getBlock(Rectangle rect) {
return mGameWorld.getForeMap((int) (rect.x + rect.width / 2) / 16,
(int) (rect.y + rect.height / 8 * 7) / 16);
}
private Rectangle getShiftedPlayerRect(float shift) {
- final Player player = mMobsController.getPlayer();
+ final Player player = mMobController.getPlayer();
return new Rectangle(player.x + shift, player.y, player.width, player.height);
}
*/
@Nullable
private Rectangle getShiftedMagnetingPlayerRect(Drop drop) {
- final Player player = mMobsController.getPlayer();
+ final Player player = mMobController.getPlayer();
- if (!player.inventory.canPickItem(drop)) {
+ if (!player.getInventory().canPickItem(drop.getItem())) {
return null;
}
return getShiftedPlayerRect(0);
}
- final Rectangle shiftedLeft = getShiftedPlayerRect(-mGameWorld.getWidthPx());
+ final float fullWorldPx = MeasureUnitsUtilsKt.getPx(mGameWorld.getWidth());
+
+ final Rectangle shiftedLeft = getShiftedPlayerRect(-fullWorldPx);
if (drop.canMagnetTo(shiftedLeft)) {
return shiftedLeft;
}
- final Rectangle shiftedRight = getShiftedPlayerRect(mGameWorld.getWidthPx());
+ final Rectangle shiftedRight = getShiftedPlayerRect(fullWorldPx);
if (drop.canMagnetTo(shiftedRight)) {
return shiftedRight;
}
}
private void pickUpDropIfPossible(Rectangle shiftedPlayerTarget, Drop drop) {
- final Player player = mMobsController.getPlayer();
+ final Player player = mMobController.getPlayer();
if (Intersector.overlaps(shiftedPlayerTarget, drop)) {
- player.inventory.pickDrop(drop);
+ // TODO: Pick up drop
+// player.getInventory().pickDrop(drop);
}
}
@Nullable Rectangle collidingRect = checkColl(mob);
if (collidingRect != null) {
- if (mob.canJump() && !mob.isFlyMode() && collidingRect.y >= mob.y + mob.height - 8) {
+ if (mob.getCanJump() && !mob.isFlyMode() && collidingRect.y >= mob.y + mob.height - 8) {
mob.y = collidingRect.y - mob.height;
return;
}
// mob.x += d;
// }
- if (mob.canJump()) {
+ if (mob.getCanJump()) {
mob.changeDir();
}
}
}
- mob.checkWorldBounds(mGameWorld);
+ // TODO: Check World Bounds
+// mob.checkWorldBounds(mGameWorld);
}
private void mobYColl(Mob mob) {
mob.y -= 1;
}
- if (mob.getY() > mGameWorld.getHeightPx()) {
+ if (mob.getY() > MeasureUnitsUtilsKt.getPx(mGameWorld.getHeight())) {
mob.kill();
}
}
}
if (getBlock(player).isFluid()) {
- if (mMainConfig.isTouch() && player.getVelocity().x != 0 && !player.swim && !player.isFlyMode()) {
- player.swim = true;
+ if (mMainConfig.isTouch() && player.getVelocity().x != 0 && !player.getSwim() && !player.isFlyMode()) {
+ player.setSwim(true);
}
- if (!player.swim) {
+ if (!player.getSwim()) {
if (!player.isFlyMode() && player.getVelocity().y < 32f) {
player.getVelocity().y += gravity.y * delta;
}
mobXColl(player);
- if (mMainConfig.isTouch() && !player.isFlyMode() && player.canJump() && player.getVelocity().x != 0 && checkJump(player)) {
+ if (mMainConfig.isTouch() && !player.isFlyMode() && player.getCanJump() && player.getVelocity().x != 0 && checkJump(player)) {
player.jump();
player.setCanJump(false);
}
}
private void mobPhy(Mob mob, float delta) {
- if (mob.getType() == Mob.Type.MOB && getBlock(mob).isFluid()) {
+ if (!(mob instanceof FallingBlock) && getBlock(mob).isFluid()) {
if (mob.getVelocity().y > 32f) {
mob.getVelocity().y -= mob.getVelocity().y * 32f * delta;
}
mob.x += mob.getVelocity().x * delta;
mobXColl(mob);
- if (mob.canJump() && mob.getVelocity().x != 0 && checkJump(mob)) {
+ if (mob.getCanJump() && mob.getVelocity().x != 0 && checkJump(mob)) {
mob.jump();
mob.setCanJump(false);
}
}
void update(float delta) {
- Player player = mMobsController.getPlayer();
+ Player player = mMobController.getPlayer();
- for (Iterator<Drop> it = mDropController.getIterator(); it.hasNext(); ) {
+ for (Iterator<Drop> it = mDropController.getAllDrop().iterator(); it.hasNext(); ) {
Drop drop = it.next();
dropPhy(drop, delta);
- if (drop.getPickedUp()) {
+ if (drop.isPickedUp()) {
it.remove();
}
}
- for (Iterator<Mob> it = mMobsController.getMobs().iterator(); it.hasNext(); ) {
+ for (Iterator<Mob> it = mMobController.getMobs().iterator(); it.hasNext(); ) {
Mob mob = it.next();
- mob.ai(mGameWorld, mGameItemsHolder, mMobsController, delta);
+ //todo: Mob ai
+// mob.ai(mGameWorld, mGameItemsHolder, mMobController, delta);
mobPhy(mob, delta);
if (mob.isDead()) {
- for (InventoryItem invItem : mob.getDrop(mGameItemsHolder)) {
+ for (InventoryItem invItem : mob.getDropItems(mGetItemByKeyUseCase)) {
mDropController.addDrop(mob.x, mob.y, invItem);
}
}
playerPhy(player, delta);
- player.ai(mGameWorld, mGameItemsHolder, mMobsController, delta);
+ //todo : Update player
+// player.ai(mGameWorld, mGameItemsHolder, mMobController, delta);
if (player.isDead()) {
- for (InventoryItem invItem : player.inventory.getItems()) {
+ for (InventoryItem invItem : player.getInventory().getItems()) {
mDropController.addDrop(player.x, player.y, invItem);
}
- player.inventory.clear();
- player.respawn(mGameWorld, mGameItemsHolder);
+ player.getInventory().clear();
+ //todo: Respawn player
+// player.respawn(mGameWorld, mGameItemsHolder);
}
}
import com.badlogic.gdx.utils.Disposable;
import com.badlogic.gdx.utils.Timer;
import ru.deadsoftware.cavedroid.MainConfig;
-import ru.deadsoftware.cavedroid.game.mobs.MobsController;
-import ru.deadsoftware.cavedroid.game.mobs.player.Player;
-import ru.deadsoftware.cavedroid.game.objects.container.ContainerController;
import ru.deadsoftware.cavedroid.game.world.GameWorldBlocksLogicControllerTask;
import ru.deadsoftware.cavedroid.game.world.GameWorldFluidsLogicControllerTask;
import ru.deadsoftware.cavedroid.game.world.GameWorldMobDamageControllerTask;
+import ru.fredboy.cavedroid.common.di.GameScope;
+import ru.fredboy.cavedroid.game.controller.container.ContainerController;
+import ru.fredboy.cavedroid.game.controller.mob.MobController;
+import ru.fredboy.cavedroid.game.controller.mob.model.Player;
import javax.inject.Inject;
private final GamePhysics mGamePhysics;
private final GameRenderer mGameRenderer;
- private final MobsController mMobsController;
+ private final MobController mMobsController;
private final ContainerController mContainerController;
- private final GameItemsHolder mGameItemsHolder;
private final GameWorldFluidsLogicControllerTask mGameWorldFluidsLogicControllerTask;
private final GameWorldBlocksLogicControllerTask mGameWorldBlocksLogicControllerTask;
private final GameWorldMobDamageControllerTask mGameWorldMobDamageControllerTask;
public GameProc(MainConfig mainConfig,
GamePhysics gamePhysics,
GameRenderer gameRenderer,
- MobsController mobsController,
+ MobController mobsController,
ContainerController containerController,
- GameItemsHolder gameItemsHolder,
GameWorldFluidsLogicControllerTask gameWorldFluidsLogicControllerTask,
GameWorldBlocksLogicControllerTask gameWorldBlocksLogicControllerTask,
GameWorldMobDamageControllerTask gameWorldMobDamageControllerTask
mGameRenderer = gameRenderer;
mMobsController = mobsController;
mContainerController = containerController;
- mGameItemsHolder = gameItemsHolder;
mGameWorldFluidsLogicControllerTask = gameWorldFluidsLogicControllerTask;
mGameWorldBlocksLogicControllerTask = gameWorldBlocksLogicControllerTask;
mGameWorldMobDamageControllerTask = gameWorldMobDamageControllerTask;
- mobsController.getPlayer().controlMode = mainConfig.isTouch() ? Player.ControlMode.WALK : Player.ControlMode.CURSOR;
+ mobsController.getPlayer().setControlMode(mainConfig.isTouch() ? Player.ControlMode.WALK : Player.ControlMode.CURSOR);
mWorldLogicTimer.scheduleTask(gameWorldFluidsLogicControllerTask, 0,
GameWorldFluidsLogicControllerTask.FLUID_UPDATE_INTERVAL_SEC);
}
public void setPlayerGameMode(int gameMode) {
- mMobsController.getPlayer().gameMode = gameMode;
+ mMobsController.getPlayer().setGameMode(gameMode);
}
public void update(float delta) {
mGamePhysics.update(delta);
mGameRenderer.render(delta);
- mContainerController.update();
+ mContainerController.update(delta);
}
public void show() {
import ru.deadsoftware.cavedroid.game.input.handler.mouse.CursorMouseInputHandler;
import ru.deadsoftware.cavedroid.game.input.mapper.KeyboardInputActionMapper;
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.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.Renderer;
-import ru.deadsoftware.cavedroid.misc.utils.RenderingUtilsKt;
+import ru.fredboy.cavedroid.common.di.GameScope;
+import ru.fredboy.cavedroid.common.utils.MeasureUnitsUtilsKt;
+import ru.fredboy.cavedroid.common.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 ru.fredboy.cavedroid.game.controller.mob.MobController;
+import ru.fredboy.cavedroid.game.controller.mob.model.Player;
+import ru.fredboy.cavedroid.game.world.GameWorld;
import javax.inject.Inject;
import java.util.*;
private static final TouchButton nullButton = new TouchButton(new Rectangle(), -1, true);
private final MainConfig mMainConfig;
- private final MobsController mMobsController;
+ private final MobController mMobsController;
private final GameWorld mGameWorld;
private final List<IGameRenderer> mRenderers;
private final CursorMouseInputHandler mCursorMouseInputHandler;
@Inject
GameRenderer(MainConfig mainConfig,
- MobsController mobsController,
+ MobController mobsController,
GameWorld gameWorld,
Set<IGameRenderer> renderers,
CursorMouseInputHandler cursorMouseInputHandler,
float camTargetX, camTargetY;
- boolean followPlayer = player.controlMode == Player.ControlMode.WALK || !mMainConfig.isTouch();
+ boolean followPlayer = player.getControlMode() == Player.ControlMode.WALK || !mMainConfig.isTouch();
if (followPlayer) {
camTargetX = plTargetX + Math.min(player.getVelocity().x * 2, getWidth() / 2);
camTargetY = plTargetY + player.getVelocity().y;
} else {
- camTargetX = MeasureUnitsUtilsKt.getPx(player.cursorX) + MeasureUnitsUtilsKt.getPx(1) / 2;
- camTargetY = MeasureUnitsUtilsKt.getPx(player.cursorY) + MeasureUnitsUtilsKt.getPx(1) / 2;
+ camTargetX = MeasureUnitsUtilsKt.getPx(player.getCursorX()) + MeasureUnitsUtilsKt.getPx(1) / 2;
+ camTargetY = MeasureUnitsUtilsKt.getPx(player.getCursorY()) + MeasureUnitsUtilsKt.getPx(1) / 2;
}
Vector2 moveVector = new Vector2(camTargetX - camCenterX, camTargetY - camCenterY);
float camX = getCamX();
float camY = getCamY();
- float worldWidth = MeasureUnitsUtilsKt.getPx(mGameWorld.getWidth()) - getWidth() / 2;
-
- if (moveVector.x >= worldWidth) {
- camX += mGameWorld.getWidthPx();
- moveVector.x -= mGameWorld.getWidthPx();
- } else if (moveVector.x <= -worldWidth) {
- camX -= mGameWorld.getWidthPx();
- moveVector.x += mGameWorld.getWidthPx();
+ float fullWorldPx = MeasureUnitsUtilsKt.getPx(mGameWorld.getWidth());
+ float worldWidthScreenOffset = fullWorldPx - getWidth() / 2;
+
+ if (moveVector.x >= worldWidthScreenOffset) {
+ camX += fullWorldPx;
+ moveVector.x -= fullWorldPx;
+ } else if (moveVector.x <= -worldWidthScreenOffset) {
+ camX -= fullWorldPx;
+ moveVector.x += fullWorldPx;
}
setCamPos(camX + moveVector.x * delta * 2, camY + moveVector.y * delta * 2);
@Nullable
private GameProc mGameProc;
- @Nullable
- private GameItemsHolder mGameItemsHolder;
@Inject
public GameScreen(MainConfig mainConfig) {
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.mobs;
-
-import com.badlogic.gdx.Gdx;
-import com.badlogic.gdx.graphics.Color;
-import com.badlogic.gdx.graphics.g2d.SpriteBatch;
-import com.badlogic.gdx.math.MathUtils;
-import com.badlogic.gdx.math.Rectangle;
-import com.badlogic.gdx.math.Vector2;
-import com.badlogic.gdx.utils.Timer;
-import org.jetbrains.annotations.Nullable;
-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.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;
-
-/**
- * Mob class.
- */
-public abstract class Mob extends Rectangle implements Saveable {
-
- private static final float DAMAGE_TINT_TIMEOUT_S = 0.5f;
- private static final Color DAMAGE_TINT_COLOR = new Color(0xff8080ff);
-
- private static final float HIT_RANGE = 8f;
-
- protected static int ANIMATION_SPEED = 360;
-
- public enum Type {
- MOB,
- FALLING_BLOCK
- }
-
- public enum Direction {
-
- LEFT(0, -1),
- RIGHT(1, 1);
-
- private final int index;
- private final int basis;
-
- /**
- * Index for this direction (left = 0, right = 1)
- */
- public final int getIndex() {
- return index;
- }
-
- /**
- * Basis for this direction (left = -1, right = 1)
- */
- public final int getBasis() {
- return basis;
- }
-
- Direction(int index, int basis) {
- this.index = index;
- this.basis = basis;
- }
- }
-
- private class ResetTakeDamageTask extends Timer.Task {
-
- @Override
- public void run() {
- mTakingDamage = false;
- }
- }
-
- protected Vector2 mVelocity;
- protected Type mType;
- protected int mAnimDelta = ANIMATION_SPEED;
- protected float mAnim;
-
- protected Direction mDirection;
- protected boolean mDead;
- protected boolean mCanJump;
- protected boolean mFlyMode;
-
- protected int mMaxHealth;
- protected int mHealth;
-
- private boolean mTakingDamage = false;
-
- @Nullable
- private ResetTakeDamageTask mResetTakeDamageTask = null;
-
- /**
- * @param x in pixels
- * @param y in pixels
- * @param width in pixels
- * @param height in pixels
- * @param mDirection Direction in which mob is looking
- */
- protected Mob(float x, float y, float width, float height, Direction mDirection, Type type, int maxHealth) {
- super(x, y, width, height);
- mVelocity = new Vector2(0, 0);
- mCanJump = false;
- mDead = false;
- this.mDirection = mDirection;
- this.mType = type;
- this.mMaxHealth = maxHealth;
- this.mHealth = mMaxHealth;
- }
-
- protected static Direction randomDir() {
- return MathUtils.randomBoolean(.5f) ? Direction.LEFT : Direction.RIGHT;
- }
-
- private boolean isAnimationIncreasing() {
- return mAnim > 0 && mAnimDelta > 0 || mAnim < 0 && mAnimDelta < 0;
- }
-
- private void checkHealth() {
- mHealth = MathUtils.clamp(mHealth, 0, mMaxHealth);
-
- if (mHealth <= 0) {
- kill();
- }
- }
-
- protected final void updateAnimation(float delta) {
- final float velocityMultiplier = (Math.abs(getVelocity().x) / getSpeed());
- final float animMultiplier = (velocityMultiplier == 0f ? 1f : velocityMultiplier) * delta;
- final float maxAnim = 60f * (velocityMultiplier == 0f ? 1f : velocityMultiplier);
-
- if (mVelocity.x != 0f || Math.abs(mAnim) > mAnimDelta * animMultiplier) {
- mAnim += mAnimDelta * animMultiplier;
- } else {
- mAnim = 0;
- }
-
- if (mAnim > maxAnim) {
- mAnim = maxAnim;
- mAnimDelta = -ANIMATION_SPEED;
- } else if (mAnim < -maxAnim) {
- mAnim = -maxAnim;
- mAnimDelta = ANIMATION_SPEED;
- }
-
- if (mVelocity.x == 0f && isAnimationIncreasing()) {
- mAnimDelta = -mAnimDelta;
- }
- }
-
- /**
- * @return The X coordinate of a mob in blocks
- */
- public final int getMapX() {
- return (int) (x + (getWidth() / 2)) / 16;
- }
-
- /**
- * @return The Y coordinate of mob's upper edge in blocks
- */
- public final int getUpperMapY() {
- return (int) (y / 16);
- }
-
- /**
- * @return The Y coordinate if mob's vertical center in blocks
- */
- public final int getMiddleMapY() {
- return (int) (y + (getHeight() / 2)) / 16;
- }
-
- /**
- * @return The Y coordinate of mob's legs in blocks
- */
- public final int getLowerMapY() {
- return (int) (y + getHeight()) / 16;
- }
-
- public final float getWidth() {
- return width;
- }
-
- public final float getHeight() {
- return height;
- }
-
- /**
- * @return Integer representing a direction in which mob is looking, where 0 is left and 1 is right
- */
- public final Direction getDirection() {
- return mDirection;
- }
-
- public final boolean looksLeft() {
- return mDirection == Direction.LEFT;
- }
-
- public final boolean looksRight() {
- return mDirection == Direction.RIGHT;
- }
-
- /**
- * Switches direction in which mob is looking
- */
- protected final void switchDir() {
- mDirection = looksLeft() ? Direction.RIGHT : Direction.LEFT;
- }
-
- public final boolean isDead() {
- return mDead;
- }
-
- public final float getAnim() {
- return mAnim;
- }
-
- /**
- * Set's mob's dead variable to true and nothing else. It doesn't delete the
- */
- public void kill() {
- mDead = true;
- }
-
- public final void move(float delta) {
- x += mVelocity.x * delta;
- y += mVelocity.y * delta;
- }
-
- public final Vector2 getVelocity() {
- return mVelocity;
- }
-
- protected final void setVelocity(Vector2 velocity) {
- mVelocity = velocity;
- }
-
- public final boolean canJump() {
- return mCanJump;
- }
-
- public final void setCanJump(boolean canJump) {
- this.mCanJump = canJump;
- }
-
- public final boolean isFlyMode() {
- return mFlyMode;
- }
-
- public final void setFlyMode(boolean flyMode) {
- this.mFlyMode = flyMode;
- }
-
- public final Type getType() {
- return mType;
- }
-
- public final void checkWorldBounds(GameWorld gameWorld) {
- if (x + width / 2 < 0) {
- x += gameWorld.getWidthPx();
- }
- if (x + width / 2 > gameWorld.getWidthPx()) {
- x -= gameWorld.getWidthPx();
- }
- }
-
- public final int getHealth() {
- return mHealth;
- }
-
- public final int getMaxHealth() {
- return mMaxHealth;
- }
-
- public final void attachToController(MobsController controller) {
- controller.addMob(this);
- }
-
- public void damage(int damage) {
- if (damage == 0) {
- return;
- }
-
- if (damage < 0) {
- Gdx.app.error(this.getClass().getSimpleName(), "Damage cant be negative!");
- return;
- }
-
- if (mHealth <= Integer.MIN_VALUE + damage) {
- mHealth = Integer.MIN_VALUE + damage;
- }
-
- mHealth -= damage;
- checkHealth();
-
- setTakingDamage(true);
- }
-
- public void heal(int heal) {
- if (heal < 0) {
- Gdx.app.error(this.getClass().getSimpleName(), "Heal cant be negative!");
- return;
- }
-
- if (mHealth >= Integer.MAX_VALUE - heal) {
- mHealth = Integer.MAX_VALUE - heal;
- }
-
- mHealth += heal;
- checkHealth();
- }
-
- public Rectangle getHitBox() {
- return new Rectangle(x - HIT_RANGE, y - HIT_RANGE, width + HIT_RANGE, height + HIT_RANGE);
- }
-
- public boolean isTakingDamage() {
- return mTakingDamage;
- }
-
- public void setTakingDamage(boolean takingDamage) {
- mTakingDamage = takingDamage;
-
- if (takingDamage) {
- if (mResetTakeDamageTask != null && mResetTakeDamageTask.isScheduled()) {
- mResetTakeDamageTask.cancel();
- } else if (mResetTakeDamageTask == null) {
- mResetTakeDamageTask = new ResetTakeDamageTask();
- }
-
- Timer.schedule(mResetTakeDamageTask, DAMAGE_TINT_TIMEOUT_S);
- }
- }
-
- protected Color getTintColor() {
- return isTakingDamage() ? DAMAGE_TINT_COLOR : Color.WHITE;
- }
-
- public List<InventoryItem> getDrop(GameItemsHolder gameItemsHolder) {
- return Collections.emptyList();
- }
-
- public abstract void draw(SpriteBatch spriteBatch, float x, float y, float delta);
-
- public abstract void ai(GameWorld gameWorld, GameItemsHolder gameItemsHolder, MobsController mobsController, float delta);
-
- public abstract void changeDir();
-
- public abstract float getSpeed();
-
- public abstract void jump();
-
- @Override
- public abstract SaveDataDto.MobSaveDataDto getSaveData();
-
- public static Mob fromSaveData(SaveDataDto.MobSaveDataDto saveData,
- GetPigSpritesUseCase getPigSpritesUseCase) {
- return MobSaveDataMapperKt.fromSaveData(saveData, getPigSpritesUseCase);
- }
-}
+++ /dev/null
-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 com.badlogic.gdx.math.Vector2;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import ru.deadsoftware.cavedroid.game.GameItemsHolder;
-import ru.deadsoftware.cavedroid.game.mobs.Mob;
-import ru.deadsoftware.cavedroid.game.mobs.MobsController;
-import ru.deadsoftware.cavedroid.game.model.block.Block;
-import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto;
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
-import ru.deadsoftware.cavedroid.game.model.item.Item;
-import ru.deadsoftware.cavedroid.game.objects.drop.Drop;
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
-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.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 static final int SAVE_DATA_VERSION = 1;
-
- private static final float SPEED = 69.072f;
- private static final float JUMP_VELOCITY = -133.332f;
- private static final int SURVIVAL_CURSOR_RANGE = 4;
-
- public static final int MAX_HEALTH = 20;
- public static final int INVENTORY_SIZE = 36;
- public static final int HOTBAR_SIZE = 9;
-
- private boolean hitting = false, hittingWithDamage = false;
- private float hitAnim = 0f;
- private float hitAnimDelta = ANIMATION_SPEED;
-
- private MobSprite.Player playerSprite;
-
- public Inventory inventory;
-
- public int gameMode;
- public boolean swim;
- public float headRotation = 0f;
-
- public float blockDamage = 0f;
- public int cursorX = 0;
- public int cursorY = 0;
-
- @Nullable
- private Vector2 spawnPoint = null;
-
- public ControlMode controlMode = ControlMode.WALK;
-
- public enum ControlMode {
- WALK,
- CURSOR
- }
-
- 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;
- }
-
- public void initInventory(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
- inventory.initItems(gameItemsHolder, tooltipManager);
- }
-
- public void respawn(GameWorld gameWorld, GameItemsHolder itemsHolder) {
- Vector2 pos = getSpawnPoint(gameWorld, itemsHolder);
- this.x = pos.x;
- this.y = pos.y;
- mVelocity.setZero();
- mDead = false;
- heal(MAX_HEALTH);
- }
-
- public void decreaseCurrentItemCount(GameItemsHolder gameItemsHolder) {
- if (gameMode == 1) {
- return;
- }
-
- final InventoryItem item = inventory.getActiveItem();
- item.subtract();
- if (item.getAmount() <= 0) {
- setCurrentInventorySlotItem(gameItemsHolder.getFallbackItem());
- }
- }
-
- public void dropCurrentItem(DropController dropController) {
- final InventoryItem activeItem = inventory.getActiveItem();
-
- }
-
- private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
- if (spawnPoint != null) {
- return spawnPoint;
- }
-
- int y, x = gameWorld.getWidth() / 2;
- for (y = 0; y <= gameWorld.getWorldConfig().getSeaLevel(); y++) {
- if (y == gameWorld.getWorldConfig().getSeaLevel()) {
- for (x = 0; x < gameWorld.getWidth(); x++) {
- if (gameWorld.getForeMap(x, y).getParams().getHasCollision()) {
- break;
- }
- if (x == gameWorld.getWidth() - 1) {
- gameWorld.setForeMap(x, y, itemsHolder.getBlock("grass"));
- break;
- }
- }
- break;
- }
- if (gameWorld.hasForeAt(x, y) && gameWorld.getForeMap(x, y).hasCollision()) {
- break;
- }
- }
- spawnPoint = new Vector2(x * 16 + 8 - getWidth() / 2, (float) y * 16 - getHeight());
- return spawnPoint;
- }
-
- public void setDir(Direction dir) {
- if (dir != getDirection()) {
- switchDir();
- }
- }
-
- public void setCurrentInventorySlotItem(Item item) {
- inventory.getItems().set(inventory.getActiveSlot(), item.toInventoryItem());
- }
-
- @Override
- public float getSpeed() {
- return SPEED;
- }
-
- @Override
- public void jump() {
- if (!canJump()) {
- if (gameMode == 1) {
- if (isFlyMode()) {
- setFlyMode(false);
- } else {
- getVelocity().y = 0f;
- setFlyMode(true);
- }
- }
- return;
- }
- mVelocity.y = JUMP_VELOCITY;
- }
-
- private boolean checkBlockCanBeHit(Block block) {
- return !block.isNone() && block.getParams().getHitPoints() >= 0;
- }
-
- /**
- * @return true if any mob fas hit
- */
- private boolean hitMobs(GameItemsHolder gameItemsHolder, MobsController mobsController) {
- if (!hitting || !hittingWithDamage) {
- return false;
- }
-
- boolean result = false;
- for (Mob mob : mobsController.getMobs()) {
- if (overlaps(mob.getHitBox())) {
- final Item activeItem = inventory.getActiveItem().getItem();
- final Item.Tool tool = activeItem.isTool() ? (Item.Tool) activeItem : null;
- if (tool != null) {
- decreaseCurrentItemCount(gameItemsHolder);
- }
- result = true;
- mob.damage(MathUtils.floor(tool != null ? tool.getMobDamageMultiplier() : 1));
- }
- }
- return result;
- }
-
- private void hitBlock(GameWorld gameWorld, GameItemsHolder gameItemsHolder) {
- if (!hitting || !hittingWithDamage) {
- return;
- }
-
- final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
- final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
-
-
- if ((checkBlockCanBeHit(foregroundBlock)) ||
- (foregroundBlock.isNone() && checkBlockCanBeHit(backgroundBlock))) {
- if (gameMode == 0) {
- if (!foregroundBlock.isNone()) {
- if (blockDamage >= foregroundBlock.getParams().getHitPoints()) {
- gameWorld.destroyForeMap(cursorX, cursorY);
- blockDamage = 0;
- }
- } else if (!backgroundBlock.isNone()) {
- if (blockDamage >= backgroundBlock.getParams().getHitPoints()) {
- gameWorld.destroyBackMap(cursorX, cursorY);
- blockDamage = 0;
- }
- }
- } else {
- if (!foregroundBlock.isNone()) {
- gameWorld.placeToForeground(cursorX, cursorY, gameItemsHolder.getFallbackBlock());
- } else if (!backgroundBlock.isNone()) {
- gameWorld.placeToBackground(cursorX, cursorY, gameItemsHolder.getFallbackBlock());
- }
- stopHitting();
- }
- } else {
- stopHitting();
- }
- }
-
- @Override
- public void ai(GameWorld gameWorld, GameItemsHolder gameItemsHolder, MobsController mobsController, float delta) {
- updateAnimation(delta);
-
- if (!hitMobs(gameItemsHolder, mobsController)) {
- hitBlock(gameWorld, gameItemsHolder);
- } else {
- stopHitting();
- }
-
- if (gameMode == 1) {
- return;
- }
-
- final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
- final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
- @Nullable final Block target;
-
- if (checkBlockCanBeHit(foregroundBlock)) {
- target = foregroundBlock;
- } else if (checkBlockCanBeHit(backgroundBlock)) {
- target = backgroundBlock;
- } else {
- target = null;
- }
-
- final boolean canHitBlock = target != null;
-
- float multiplier = 1f;
- final Item currentItem = inventory.getActiveItem().getItem();
- if (currentItem instanceof Item.Tool && canHitBlock) {
- if (target.getParams().getToolType() == currentItem.getClass()
- && ((Item.Tool)currentItem).getLevel() >= target.getParams().getToolLevel()) {
- multiplier = 2f * ((Item.Tool)currentItem).getLevel();
- }
- multiplier *= ((Item.Tool)currentItem).getBlockDamageMultiplier();
- }
-
- if (hitting && hittingWithDamage && canHitBlock) {
- blockDamage += 60f * delta * multiplier;
- } else {
- blockDamage = 0f;
- }
- }
-
- @Override
- public void changeDir() {
- }
-
- @Override
- public void damage(int damage) {
- if (gameMode == 1) {
- return;
- }
-
- if (damage > 0) {
- getVelocity().y += JUMP_VELOCITY / 3f;
- }
-
- super.damage(damage);
- }
-
- @Override
- public void heal(int heal) {
- if (gameMode == 1) {
- return;
- }
- super.heal(heal);
- }
-
- public void checkCursorBounds(GameWorld gameWorld) {
- if (gameMode == 0) {
- int minCursorX = getMapX() - SURVIVAL_CURSOR_RANGE;
- int maxCursorX = getMapX() + SURVIVAL_CURSOR_RANGE;
- int minCursorY = getMiddleMapY() - SURVIVAL_CURSOR_RANGE;
- int maxCursorY = getMiddleMapY() + SURVIVAL_CURSOR_RANGE;
-
- cursorX = MathUtils.clamp(cursorX, minCursorX, maxCursorX);
- cursorY = MathUtils.clamp(cursorY, minCursorY, maxCursorY);
- }
-
- cursorY = MathUtils.clamp(cursorY, 0, gameWorld.getHeight() - 1);
- }
-
- private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
- final Item item = inventory.getActiveItem().getItem();
-
- if (item == null || item.isNone()) {
- return;
- }
-
- final Sprite sprite = item.getSprite();
- final boolean smallSprite = !item.isTool() || item.isShears();
-
- final float originalWidth = sprite.getWidth();
- final float originalHeight = sprite.getHeight();
-
- if (smallSprite) {
- sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
- }
-
- final float handLength = playerSprite.getHand().getHeight();
-
- final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
- final int handMultiplier = -getDirection().getBasis();
- final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
- final float yOffset = !smallSprite ? -sprite.getHeight() / 2 : 0;
-
- float rotate = anim + 30;
-
- if (item.isTool()) {
- sprite.rotate90(looksLeft());
- }
-
- final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
- final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
-
- if (looksLeft()) {
- sprite.setFlip(!item.isTool(), sprite.isFlipY());
- SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
- } else {
- sprite.setFlip(item.isTool(), sprite.isFlipY());
- SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
- }
-
- sprite.setRotation(-handMultiplier * rotate);
- sprite.setPosition(itemX, itemY);
- sprite.draw(spriteBatch);
-
- // dont forget to reset
- sprite.setFlip(false, sprite.isFlipY());
- sprite.setRotation(0);
- sprite.setOriginCenter();
- sprite.setSize(originalWidth, originalHeight);
- if (item.isTool()) {
- sprite.rotate90(looksRight());
- }
- }
-
- public void startHitting(boolean withDamage) {
- if (hitting) {
- return;
- }
-
- hitting = true;
- hittingWithDamage = withDamage;
- hitAnim = 90f;
- hitAnimDelta = ANIMATION_SPEED;
- }
-
- public void startHitting() {
- startHitting(true);
- }
-
- public void stopHitting() {
- blockDamage = 0f;
- hitting = false;
- }
-
- private float getRightHandAnim(float delta) {
- hitAnim -= hitAnimDelta * delta;
-
- if (hitAnim < 30f || hitAnim > 90f) {
- if (hitting) {
- hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
- hitAnimDelta = -hitAnimDelta;
- } else {
- hitAnimDelta = ANIMATION_SPEED;
- }
- }
-
- if (!hitting) {
- if (hitAnim < hitAnimDelta * delta) {
- hitAnim = 0;
- hitAnimDelta = 0;
- return -mAnim;
- }
- }
-
- return hitAnim;
- }
-
- @Override
- public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
- 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;
-
- final float rightHandAnim = getRightHandAnim(delta);
-
- if (looksLeft()) {
- backHandAnim = rightHandAnim;
- frontHandAnim = mAnim;
- } else {
- backHandAnim = -mAnim;
- frontHandAnim = -rightHandAnim;
- }
-
- final Color backgroundTintColor = getTintColor().cpy().sub(new Color(0xAAAAAA00));
-
- hand.setColor(backgroundTintColor);
- SpriteUtilsKt.drawSprite(spriteBatch, hand, x + 2, y + 8, backHandAnim);
-
- if (looksLeft()) {
- drawItem(spriteBatch, x, y, -backHandAnim);
- }
-
- 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);
- }
-
- hand.setColor(getTintColor());
- SpriteUtilsKt.drawSprite(spriteBatch, hand, x + 2, y + 8, frontHandAnim);
- }
-
- @NotNull
- @Override
- public SaveDataDto.PlayerSaveData getSaveData() {
- return new SaveDataDto.PlayerSaveData(
- SAVE_DATA_VERSION,
- mType,
- mAnimDelta,
- mAnim,
- mDirection,
- mDead,
- mCanJump,
- mFlyMode,
- mMaxHealth,
- mHealth,
- x,
- y,
- width,
- height,
- getVelocity().x,
- getVelocity().y,
- hitting,
- hittingWithDamage,
- hitAnim,
- hitAnimDelta,
- inventory.getSaveData(),
- gameMode,
- swim,
- headRotation,
- blockDamage,
- cursorX,
- cursorY,
- spawnPoint != null ? spawnPoint.x : 0f,
- spawnPoint != null ? spawnPoint.y : 0f,
- controlMode
- );
- }
-
- public static Player fromSaveData(
- SaveDataDto.PlayerSaveData saveData,
- GameItemsHolder gameItemsHolder,
- TooltipManager tooltipManager,
- GetPlayerSpritesUseCase getPlayerSpritesUseCase
- ) {
- saveData.verifyVersion(SAVE_DATA_VERSION);
-
- Player player = new Player(gameItemsHolder, tooltipManager, getPlayerSpritesUseCase.invoke());
-
- player.mType = saveData.getType();
- player.mAnimDelta = saveData.getAnimDelta();
- player.mAnim = saveData.getAnim();
- player.mDirection = saveData.getDirection();
- player.mDead = saveData.getDead();
- player.mCanJump = saveData.getCanJump();
- player.mFlyMode = saveData.getFlyMode();
- player.mMaxHealth = saveData.getMaxHealth();
- player.mHealth = saveData.getHealth();
- player.x = saveData.getX();
- player.y = saveData.getY();
- player.width = saveData.getWidth();
- player.height = saveData.getHeight();
- player.hitting = saveData.getHitting();
- player.hittingWithDamage = saveData.getHittingWithDamage();
- player.hitAnim = saveData.getHitAnim();
- player.hitAnimDelta = saveData.getHitAnimDelta();
- player.inventory = Inventory.Companion.fromSaveData(saveData.getInventory(), gameItemsHolder, tooltipManager);
- player.gameMode = saveData.getGameMode();
- player.swim = saveData.getSwim();
- player.headRotation = saveData.getHeadRotation();
- player.blockDamage = saveData.getBlockDamage();
- player.cursorX = saveData.getCursorX();
- player.cursorY = saveData.getCursorY();
- player.spawnPoint = new Vector2(saveData.getSpawnPointX(), saveData.getSpawnPointY());
- player.controlMode = saveData.getControlMode();
-
- return player;
- }
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.objects.drop;
-
-import org.jetbrains.annotations.NotNull;
-import ru.deadsoftware.cavedroid.game.GameItemsHolder;
-import ru.deadsoftware.cavedroid.game.GameScope;
-import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto;
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
-import ru.deadsoftware.cavedroid.game.model.item.Item;
-import ru.deadsoftware.cavedroid.misc.Saveable;
-
-import javax.inject.Inject;
-import java.util.Iterator;
-import java.util.LinkedList;
-
-@GameScope
-public class DropController implements Saveable {
-
- private static final int SAVE_DATA_VERSION = 1;
-
- public interface Callback {
- void run(Drop drop);
- }
-
- private final LinkedList<Drop> mDrops = new LinkedList<>();
-
- @Inject
- public DropController() {
- }
-
- public void initDrops(GameItemsHolder gameItemsHolder) {
- for (Drop drop : mDrops) {
- drop.initItem(gameItemsHolder);
- }
- }
-
- public void addDrop(float x, float y, Item item) {
- addDrop(x, y, item, 1);
- }
-
- public void addDrop(float x, float y, Item item, int count) {
- if (item.isNone()) {
- return;
- }
- mDrops.add(new Drop(x, y, item, count));
- }
-
- public void addDrop(float x, float y, @NotNull InventoryItem invItem) {
- addDrop(x, y, invItem.getItem(), invItem.getAmount());
- }
-
- public int getSize() {
- return mDrops.size();
- }
-
- public void forEach(Callback callback) {
- for (Drop drop : mDrops) {
- callback.run(drop);
- }
- }
-
- public Iterator<Drop> getIterator() {
- return mDrops.iterator();
- }
-
- @Override
- @NotNull
- public SaveDataDto.DropControllerSaveData getSaveData() {
- final LinkedList<SaveDataDto.DropSaveData> dropSaveData = new LinkedList<>();
- for (Drop drop : mDrops) {
- dropSaveData.add(drop.getSaveData());
- }
- return new SaveDataDto.DropControllerSaveData(SAVE_DATA_VERSION, dropSaveData);
- }
-
- public static DropController fromSaveData(
- SaveDataDto.DropControllerSaveData saveData, GameItemsHolder gameItemsHolder) {
- saveData.verifyVersion(SAVE_DATA_VERSION);
-
- DropController controller = new DropController();
-
- for (SaveDataDto.DropSaveData dropSaveData : saveData.getDrops()) {
- controller.mDrops.add(Drop.Companion.fromSaveData(dropSaveData, gameItemsHolder));
- }
-
- return controller;
- }
-
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.world;
-
-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.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.container.ContainerController;
-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;
-
-@GameScope
-public class GameWorld {
-
- private static final int FOREGROUND_Z = 0;
- private static final int BACKGROUND_Z = 1;
-
- private final DropController mDropController;
- private final MobsController mMobsController;
- private final GameItemsHolder mGameItemsHolder;
- private final ContainerController mContainerController;
-
- private final int mWidth;
- private final int mHeight;
- private final Block[][] mForeMap;
- private final Block[][] mBackMap;
-
- private final WorldGeneratorConfig mWorldConfig = WorldGeneratorConfig.Companion.getDefault();
-
- @Inject
- public GameWorld(DropController dropController,
- MobsController mobsController,
- GameItemsHolder gameItemsHolder,
- ContainerController containerController,
- @Nullable Block[][] foreMap,
- @Nullable Block[][] backMap) {
- mDropController = dropController;
- mMobsController = mobsController;
- mGameItemsHolder = gameItemsHolder;
- mContainerController = containerController;
-
- boolean isNewGame = foreMap == null || backMap == null;
-
- if (isNewGame) {
- mWidth = mWorldConfig.getWidth();
- mHeight = mWorldConfig.getHeight();
- Pair<Block[][], Block[][]> maps = new GameWorldGenerator(mWorldConfig, mGameItemsHolder).generate();
- mForeMap = maps.getFirst();
- mBackMap = maps.getSecond();
- spawnInitialMobs();
- mMobsController.getPlayer().respawn(this, mGameItemsHolder);
- } else {
- mForeMap = foreMap;
- mBackMap = backMap;
- mWidth = mForeMap.length;
- mHeight = mForeMap[0].length;
- }
- }
-
- public int getWidth() {
- return mWidth;
- }
-
- public int getHeight() {
- return mHeight;
- }
-
- /**
- * @deprecated for kotlin use {@link MeasureUnitsUtilsKt#getPx } extension val
- */
- @Deprecated
- public float getWidthPx() {
- return MeasureUnitsUtilsKt.getPx(mWidth);
- }
-
- /**
- * @deprecated for kotlin use {@link MeasureUnitsUtilsKt#getPx } extension val
- */
- @Deprecated
- public float getHeightPx() {
- return MeasureUnitsUtilsKt.getPx(mHeight);
- }
-
- public Block[][] getFullForeMap() {
- return mForeMap;
- }
-
- public Block[][] getFullBackMap() {
- return mBackMap;
- }
-
- private int transformX(int x) {
- x = x % getWidth();
- if (x < 0) {
- x = getWidth() - Math.abs(x);
- }
- return x;
- }
-
- private Block getMap(int x, int y, int layer) {
- Block map = mGameItemsHolder.getFallbackBlock();
-
- if (y < 0 || y >= getHeight()) {
- return map;
- }
-
- x = transformX(x);
-
- if (x < 0 || x >= getWidth()) {
- return map;
- }
-
- map = (layer == 0) ? mForeMap[x][y] : mBackMap[x][y];
-
- return map;
- }
-
- private void setMap(int x, int y, int layer, Block value) {
- if (y < 0 || y >= getHeight()) {
- return;
- }
-
- x = transformX(x);
-
- if (x < 0 || x >= getWidth()) {
- return;
- }
-
- mContainerController.destroyContainer(x, y, layer, false);
-
- if (value.isContainer()) {
- mContainerController.addContainer(x, y, layer, (Class<? extends Block.Container>) value.getClass());
- }
-
- if (layer == 0) {
- mForeMap[x][y] = value;
- } else {
- mBackMap[x][y] = value;
- }
- }
-
- private boolean isSameSlab(Block slab1, Block slab2) {
- if (!(slab1 instanceof Block.Slab) || !(slab2 instanceof Block.Slab)) {
- return false;
- }
-
- return slab1.getParams().getKey().equals(((Block.Slab) slab2).getOtherPartBlockKey())
- || slab1.getParams().getKey().equals(slab2.getParams().getKey());
- }
-
- public boolean hasForeAt(int x, int y) {
- return getMap(x, y, FOREGROUND_Z) != mGameItemsHolder.getFallbackBlock();
- }
-
- public boolean hasBackAt(int x, int y) {
- return getMap(x, y, BACKGROUND_Z) != mGameItemsHolder.getFallbackBlock();
- }
-
- public Block getForeMap(int x, int y) {
- return getMap(x, y, FOREGROUND_Z);
- }
-
- public void setForeMap(int x, int y, Block block) {
- setMap(x, y, FOREGROUND_Z, block);
- }
-
- public void resetForeMap(int x, int y) {
- setForeMap(x, y, mGameItemsHolder.getFallbackBlock());
- }
-
- public Block getBackMap(int x, int y) {
- return getMap(x, y, BACKGROUND_Z);
- }
-
- public void setBackMap(int x, int y, Block block) {
- setMap(x, y, BACKGROUND_Z, block);
- }
-
- public boolean canPlaceToForeground(int x, int y, Block value) {
- return !hasForeAt(x, y) || value == mGameItemsHolder.getFallbackBlock() || !getForeMap(x, y).hasCollision();
- }
-
- public boolean placeToForeground(int x, int y, Block value) {
- if (canPlaceToForeground(x, y, value)) {
- setForeMap(x, y, value);
- return true;
- } else if (value instanceof Block.Slab && isSameSlab(value, getForeMap(x, y))) {
- setForeMap(x, y, mGameItemsHolder.getBlock(((Block.Slab) value).getFullBlockKey()));
- return true;
- }
- return false;
- }
-
- public boolean placeToBackground(int x, int y, Block value) {
- if (value == mGameItemsHolder.getFallbackBlock() || (getBackMap(x, y) == mGameItemsHolder.getFallbackBlock() && value.hasCollision()) &&
- (!value.isTransparent() || value == mGameItemsHolder.getBlock("glass") || value.isChest() || value.isSlab())) {
- setBackMap(x, y, value);
- return true;
- }
- return false;
- }
-
- private void playerDurateTool() {
- final InventoryItem playerCurrentItem = mMobsController.getPlayer().inventory.getActiveItem();
- if (playerCurrentItem.getItem().isTool()) {
- mMobsController.getPlayer().decreaseCurrentItemCount(mGameItemsHolder);
- }
- }
-
- private boolean shouldDrop(Block block) {
- final Item item = mMobsController.getPlayer().inventory.getActiveItem().getItem();
- int toolLevel = item.isTool() ? ((Item.Tool) item).getLevel() : 0;
- if (item.isTool() && block.getParams().getToolType() != item.getClass()) {
- toolLevel = 0;
- }
- return toolLevel >= block.getParams().getToolLevel();
- }
-
- 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++;
-// }
-// }
- }
-
- public void destroyForeMap(int x, int y) {
- Block block = getForeMap(x, y);
- if (block.isContainer()) {
- mContainerController.destroyContainer(x, y, FOREGROUND_Z, true);
- }
- if (block.hasDrop() && shouldDrop(block)) {
- for (int i = 0; i < block.getParams().getDropInfo().getCount(); i++) {
- mDropController.addDrop(transformX(x) * 16 + 4, y * 16 + 4, mGameItemsHolder.getItem(block.getDrop()));
- }
- }
- playerDurateTool();
- placeToForeground(x, y, mGameItemsHolder.getFallbackBlock());
- }
-
- public WorldGeneratorConfig getWorldConfig() {
- return mWorldConfig;
- }
-
- public void destroyBackMap(int x, int y) {
- Block block = getBackMap(x, y);
- if (block.isContainer()) {
- mContainerController.destroyContainer(x, y, BACKGROUND_Z, true);
- }
- if (block.hasDrop() && shouldDrop(block)) {
- for (int i = 0; i < block.getParams().getDropInfo().getCount(); i++) {
- mDropController.addDrop(transformX(x) * 16 + 4, y * 16 + 4, mGameItemsHolder.getItem(block.getDrop()));
- }
- }
- playerDurateTool();
- placeToBackground(x, y, mGameItemsHolder.getFallbackBlock());
- }
-
- @Nullable
- private Container getContainerAt(int x, int y, int z) {
- return mContainerController.getContainer(transformX(x), y, z);
- }
-
- @Nullable
- public Container getForegroundContainer(int x, int y) {
- return getContainerAt(x, y, FOREGROUND_Z);
- }
-
- @Nullable
- public Container getBackgroundContainer(int x, int y) {
- return getContainerAt(x, y, BACKGROUND_Z);
- }
-
- @Nullable
- public Furnace getForegroundFurnace(int x, int y) {
- @Nullable
- final Container container = getForegroundContainer(x, y);
-
- if (container instanceof Furnace) {
- return (Furnace) container;
- }
-
- return null;
- }
-
- @Nullable
- public Furnace getBackgroundFurnace(int x, int y) {
- @Nullable
- final Container container = getBackgroundContainer(x, y);
-
- if (container instanceof Furnace) {
- return (Furnace) container;
- }
-
- return null;
- }
-}
\ No newline at end of file
import dagger.Component;
import ru.deadsoftware.cavedroid.MainComponent;
+import ru.fredboy.cavedroid.data.save.di.DataSaveModule;
@MenuScope
-@Component(dependencies = MainComponent.class)
+@Component(dependencies = MainComponent.class, modules = DataSaveModule.class)
public interface MenuComponent {
MenuProc getMenuProc();
}
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.common.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 java.util.regex.Matcher;
import java.util.regex.Pattern;
-import static ru.deadsoftware.cavedroid.misc.Assets.*;
-
@MenuScope
public class MenuProc extends Renderer {
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.utils.ArrayMap;
import com.badlogic.gdx.utils.JsonValue;
-import kotlin.text.StringsKt;
import ru.deadsoftware.cavedroid.MainConfig;
import ru.deadsoftware.cavedroid.menu.MenuProc;
import ru.deadsoftware.cavedroid.menu.objects.BooleanOptionButton;
mMenuInput = menuInput;
mAssetLoader = assetLoader;
mGetTextureRegionByNameUseCase = getTextureRegionByNameUseCase;
+ }
+
+ final void init() {
initButtons();
}
package ru.deadsoftware.cavedroid.menu.submenus;
import ru.deadsoftware.cavedroid.MainConfig;
-import ru.deadsoftware.cavedroid.game.save.GameSaveLoader;
import ru.deadsoftware.cavedroid.menu.MenuProc;
import ru.deadsoftware.cavedroid.menu.objects.Button;
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 ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository;
-import javax.inject.Inject;
import java.util.HashMap;
public class MenuMain extends Menu {
+ private final SaveDataRepository mSaveDataRepository;
+
public MenuMain(float width,
float height,
ButtonRenderer buttonRenderer,
MainConfig mainConfig,
MenuProc.Input menuInput,
AssetLoader assetLoader,
- GetTextureRegionByNameUseCase getTextureRegionByNameUseCase) {
+ GetTextureRegionByNameUseCase getTextureRegionByNameUseCase,
+ SaveDataRepository saveDataRepository) {
super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByNameUseCase);
+ mSaveDataRepository = saveDataRepository;
}
@Override
@Override
protected void initButtons() {
loadButtonsFromJson(mAssetLoader.getAssetHandle("json/menu_main_buttons.json"));
- if (GameSaveLoader.INSTANCE.exists(mMainConfig)) {
+ if (mSaveDataRepository.exists(mMainConfig.getGameFolder())) {
getButtons().get("load_game").setType(Button.NORMAL);
}
}
import com.badlogic.gdx.Application
import com.badlogic.gdx.Game
import com.badlogic.gdx.Gdx
-import ru.deadsoftware.cavedroid.misc.Assets
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
-import ru.deadsoftware.cavedroid.misc.utils.ratio
import ru.deadsoftware.cavedroid.prefs.PreferencesStore
+import ru.fredboy.cavedroid.common.utils.ratio
class CaveGame(
private val gameDataDirectoryPath: String,
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.data.items.di.DataItemsModule
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 ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import javax.inject.Singleton
@Singleton
@Component(
dependencies = [CaveGame::class, PreferencesStore::class],
- modules = [DataAssetsModule::class]
+ modules = [DataAssetsModule::class, DataItemsModule::class]
)
interface MainComponent {
val touchButtonsAssetsRepository: TouchButtonsAssetsRepository
+ val itemsRepository: ItemsRepository
+
}
\ No newline at end of file
import ru.deadsoftware.cavedroid.game.actions.updateblock.UpdateRequiresBlockAction
import ru.deadsoftware.cavedroid.game.actions.placeblock.PlaceBlockItemToBackgroundAction
import ru.deadsoftware.cavedroid.game.actions.placeblock.PlaceBlockItemToForegroundAction
-import ru.deadsoftware.cavedroid.game.model.item.Item
+import ru.fredboy.cavedroid.domain.items.model.item.Item
private const val TAG = "PlaceBlockActionUtils"
package ru.deadsoftware.cavedroid.game.actions.placeblock
-import ru.deadsoftware.cavedroid.game.model.item.Item
+import ru.fredboy.cavedroid.domain.items.model.item.Item
interface IPlaceBlockAction {
package ru.deadsoftware.cavedroid.game.actions.placeblock
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindPlaceBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindPlaceBlockAction(stringKey = PlaceBlockItemToBackgroundAction.ACTION_KEY)
class PlaceBlockItemToBackgroundAction @Inject constructor(
private val gameWorld: GameWorld,
- private val gameItemsHolder: GameItemsHolder,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IPlaceBlockAction {
override fun place(placeable: Item.Placeable, x: Int, y: Int) {
if (gameWorld.placeToBackground(x, y, placeable.block)) {
- mobsController.player.decreaseCurrentItemCount(gameItemsHolder)
+ mobController.player.decreaseCurrentItemCount()
}
}
package ru.deadsoftware.cavedroid.game.actions.placeblock
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindPlaceBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
class PlaceBlockItemToForegroundAction @Inject constructor(
private val gameWorld: GameWorld,
private val placeSlabAction: PlaceSlabAction,
- private val gameItemsHolder: GameItemsHolder,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IPlaceBlockAction {
override fun place(placeable: Item.Placeable, x: Int, y: Int) {
placeSlabAction.place(placeable, x, y)
} else {
if (gameWorld.placeToForeground(x, y, placeable.block)) {
- mobsController.player.decreaseCurrentItemCount(gameItemsHolder)
+ mobController.player.decreaseCurrentItemCount()
}
}
}
package ru.deadsoftware.cavedroid.game.actions.placeblock
import com.badlogic.gdx.Gdx
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindPlaceBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindPlaceBlockAction(stringKey = PlaceSlabAction.ACTION_KEY)
class PlaceSlabAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
) : IPlaceBlockAction {
override fun place(placeable: Item.Placeable, x: Int, y: Int) {
}
if (gameWorld.placeToForeground(x, y, slabPart)) {
- mobsController.player.decreaseCurrentItemCount(gameItemsHolder)
+ mobController.player.decreaseCurrentItemCount()
}
}
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUpdateBlockAction(stringKey = UpdateBedLeftAction.BLOCK_KEY)
class UpdateBedLeftAction @Inject constructor(
private val gameWorld: GameWorld,
- private val gameItemsHolder: GameItemsHolder,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
) : IUpdateBlockAction {
override fun update(x: Int, y: Int) {
- val bedRight = gameItemsHolder.getBlock("bed_r")
+ val bedRight = getBlockByKeyUseCase["bed_r"]
if (gameWorld.getForeMap(x + 1, y) != bedRight) {
gameWorld.resetForeMap(x, y)
}
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUpdateBlockAction(stringKey = UpdateBedRightAction.BLOCK_KEY)
class UpdateBedRightAction @Inject constructor(
private val gameWorld: GameWorld,
- private val gameItemsHolder: GameItemsHolder,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
) : IUpdateBlockAction {
override fun update(x: Int, y: Int) {
- val bedLeft = gameItemsHolder.getBlock("bed_l")
+ val bedLeft = getBlockByKeyUseCase["bed_l"]
if (gameWorld.getForeMap(x - 1, y) != bedLeft) {
gameWorld.resetForeMap(x, y)
}
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUpdateBlockAction(stringKey = UpdateGrassAction.BLOCK_KEY)
class UpdateGrassAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mGameItemsHolder: GameItemsHolder,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
) : IUpdateBlockAction {
override fun update(x: Int, y: Int) {
val makesDirt = blockOnTop.params.hasCollision || blockOnTop.isFluid()
when {
- makesDirt -> gameWorld.setForeMap(x, y, mGameItemsHolder.getBlock("dirt"))
- blockOnTop.params.key == "snow" -> gameWorld.setForeMap(x, y, mGameItemsHolder.getBlock("grass_snowed"))
+ makesDirt -> gameWorld.setForeMap(x, y, getBlockByKeyUseCase["dirt"])
+ blockOnTop.params.key == "snow" -> gameWorld.setForeMap(x, y, getBlockByKeyUseCase["grass_snowed"])
}
}
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.FallingBlock
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.FallingBlock
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUpdateBlockAction(stringKey = UpdateRequiresBlockAction.ACTION_KEY)
class UpdateRequiresBlockAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IUpdateBlockAction {
override fun update(x: Int, y: Int) {
if (block.params.isFallable) {
gameWorld.resetForeMap(x, y)
- FallingBlock(block.params.key, x.px, y.px)
- .attachToController(mobsController)
+ FallingBlock(block, x.px, y.px)
+ .attachToController(mobController)
} else {
gameWorld.destroyForeMap(x, y)
}
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUpdateBlockAction(stringKey = UpdateSnowedGrassAction.BLOCK_KEY)
class UpdateSnowedGrassAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mGameItemsHolder: GameItemsHolder,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
) : IUpdateBlockAction {
override fun update(x: Int, y: Int) {
val makesDirt = blockOnTop.params.hasCollision || blockOnTop.isFluid()
when {
- makesDirt -> gameWorld.setForeMap(x, y, mGameItemsHolder.getBlock("dirt"))
- blockOnTop.params.key != "snow" -> gameWorld.setForeMap(x, y, mGameItemsHolder.getBlock("grass"))
+ makesDirt -> gameWorld.setForeMap(x, y, getBlockByKeyUseCase["dirt"])
+ blockOnTop.params.key != "snow" -> gameWorld.setForeMap(x, y, getBlockByKeyUseCase["grass"])
}
}
package ru.deadsoftware.cavedroid.game.actions.useblock
-import ru.deadsoftware.cavedroid.game.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.block.Block
interface IUseBlockAction {
package ru.deadsoftware.cavedroid.game.actions.useblock
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.objects.container.Chest
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.game.controller.container.model.Chest
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.actions.useblock
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.model.block.Block
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.block.Block
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.actions.useblock
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.model.block.Block
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseBlockAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.game.model.item.Item
+import ru.fredboy.cavedroid.domain.items.model.item.Item
interface IUseItemAction {
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUseItemAction(UseBedAction.ACTION_KEY)
class UseBedAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
- val bedLeft = gameItemsHolder.getBlock("bed_l")
- val bedRight = gameItemsHolder.getBlock("bed_r")
+ val bedLeft = getBlockByKeyUseCase["bed_l"]
+ val bedRight = getBlockByKeyUseCase["bed_r"]
if (gameWorld.canPlaceToForeground(x, y, bedLeft) && gameWorld.canPlaceToForeground(x + 1, y, bedRight)) {
gameWorld.placeToForeground(x, y, bedLeft)
gameWorld.placeToForeground(x + 1, y, bedRight)
- mobsController.player.inventory.decreaseCurrentItemAmount()
+ mobController.player.inventory.decreaseCurrentItemAmount()
}
}
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-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.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUseItemAction(UseEmptyBucketAction.ACTION_KEY)
class UseEmptyBucketAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
}
gameWorld.resetForeMap(x, y)
- @Suppress("REDUNDANT_ELSE_IN_WHEN")
val filled = when (foregroundBlock) {
- is Block.Lava -> gameItemsHolder.getItem("bucket_lava")
- is Block.Water -> gameItemsHolder.getItem("bucket_water")
+ is Block.Lava -> getItemByKeyUseCase["bucket_lava"]
+ is Block.Water -> getItemByKeyUseCase["bucket_water"]
else -> throw IllegalStateException("unknown fluid")
}
- mobsController.player.setCurrentInventorySlotItem(filled)
+ mobController.player.setCurrentInventorySlotItem(filled)
}
companion object {
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUseItemAction(UseLavaBucketAction.ACTION_KEY)
class UseLavaBucketAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
- gameWorld.placeToForeground(x, y, gameItemsHolder.getBlock("lava"))
+ gameWorld.placeToForeground(x, y, getBlockByKeyUseCase["lava"])
- if (mobsController.player.gameMode != 1) {
- mobsController.player.setCurrentInventorySlotItem(gameItemsHolder.getItem("bucket_empty"))
+ if (mobController.player.gameMode != 1) {
+ mobController.player.setCurrentInventorySlotItem(getItemByKeyUseCase["bucket_empty"])
}
}
package ru.deadsoftware.cavedroid.game.actions.useitem
-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.item.Item
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Pig
import javax.inject.Inject
@GameScope
@BindUseItemAction(UsePigSpawnEggAction.ACTION_KEY)
class UsePigSpawnEggAction @Inject constructor(
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
private val getPigSprites: GetPigSpritesUseCase,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
- Pig(getPigSprites(), mobsController.player.cursorX.px, mobsController.player.cursorY.px)
- .apply {
- attachToController(mobsController)
- }
+ Pig(getPigSprites(), mobController.player.cursorX.px, mobController.player.cursorY.px)
+ .apply { attachToController(mobController) }
- mobsController.player.decreaseCurrentItemCount(gameItemsHolder)
+ mobController.player.decreaseCurrentItemCount()
}
companion object {
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUseItemAction(UseWaterBucketAction.ACTION_KEY)
class UseWaterBucketAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobsController: MobController,
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
- gameWorld.placeToForeground(x, y, gameItemsHolder.getBlock("water"))
+ gameWorld.placeToForeground(x, y, getBlockByKeyUseCase["water"])
if (mobsController.player.gameMode != 1) {
- mobsController.player.setCurrentInventorySlotItem(gameItemsHolder.getItem("bucket_empty"))
+ mobsController.player.setCurrentInventorySlotItem(getItemByKeyUseCase["bucket_empty"])
}
}
package ru.deadsoftware.cavedroid.game.debug
import com.badlogic.gdx.Gdx
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.objects.container.ContainerController
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
-import ru.deadsoftware.cavedroid.game.world.GameWorld
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
class DebugInfoStringsProvider @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val dropController: DropController,
private val containerController: ContainerController,
private val gameWorld: GameWorld,
) {
fun getDebugStrings(): List<String> {
- val player = mobsController.player
+ val player = mobController.player
return listOf(
"FPS: ${Gdx.graphics.framesPerSecond}",
"CurY: ${player.cursorY}",
"Velocity: ${player.velocity}",
"Swim: ${player.swim}",
- "Mobs: ${mobsController.mobs.size}",
+ "Mobs: ${mobController.mobs.size}",
"Drops: ${dropController.size}",
"Containers: ${containerController.size}",
"Block: ${gameWorld.getForeMap(player.cursorX, player.cursorY).params.key}",
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class CloseGameWindowKeyboardInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val dropController: DropController,
) : IKeyboardInputHandler {
if (selectedItem != null) {
for (i in 1 .. selectedItem.amount) {
dropController.addDrop(
- /* x = */ mobsController.player.x + (32f * mobsController.player.direction.basis),
- /* y = */ mobsController.player.y,
- /* item = */ selectedItem.item
+ /* x = */ mobController.player.x + (32f * mobController.player.direction.basis),
+ /* y = */ mobController.player.y,
+ /* item = */ selectedItem
)
}
gameWindowsManager.currentWindow?.selectedItem = null
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.objects.drop.Drop
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class DropItemKeyboardInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val dropController: DropController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.DropItem &&
action.isKeyDown && gameWindowsManager.getCurrentWindow() == GameUiWindow.NONE &&
- !mobsController.player.inventory.activeItem.item.isNone()
+ !mobController.player.inventory.activeItem.item.isNone()
}
private fun createDrop(item: Item, playerX: Float, playerY: Float, amount: Int) {
dropController.addDrop(
- /* x = */ playerX + ((DROP_DISTANCE - Drop.DROP_SIZE / 2) * mobsController.player.direction.basis),
+ /* x = */ playerX + ((DROP_DISTANCE - Drop.DROP_SIZE / 2) * mobController.player.direction.basis),
/* y = */ playerY,
/* item = */ item,
/* count = */ amount
}
override fun handle(action: KeyboardInputAction) {
- val player = mobsController.player
+ val player = mobController.player
val currentItem = player.inventory.activeItem
val dropAmount = if (currentItem.item.isTool()) currentItem.amount else 1
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class FlyDownKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Down &&
- mobsController.player.isFlyMode &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ mobController.player.isFlyMode &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
if (action.isKeyDown) {
- mobsController.player.velocity.y = mobsController.player.speed
+ mobController.player.velocity.y = mobController.player.speed
} else {
- mobsController.player.velocity.y = 0f
+ mobController.player.velocity.y = 0f
}
}
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class FlyUpKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up &&
- !mobsController.player.swim &&
- mobsController.player.isFlyMode &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ !mobController.player.swim &&
+ mobController.player.isFlyMode &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
if (action.isKeyDown) {
- mobsController.player.velocity.y = -mobsController.player.speed
+ mobController.player.velocity.y = -mobController.player.speed
} else {
- mobsController.player.velocity.y = 0f
+ mobController.player.velocity.y = 0f
}
}
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Direction
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class GoLeftKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Left &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch) &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch) &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
if (action.isKeyDown) {
- mobsController.player.velocity.x = -mobsController.player.speed
- mobsController.player.setDir(Mob.Direction.LEFT)
+ mobController.player.velocity.x = -mobController.player.speed
+ mobController.player.direction = Direction.LEFT
} else {
- mobsController.player.velocity.x = 0f
+ mobController.player.velocity.x = 0f
}
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Direction
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class GoRightKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController
+ private val mobController: MobController
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Right &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
if (action.isKeyDown) {
- mobsController.player.velocity.x = mobsController.player.speed
- mobsController.player.setDir(Mob.Direction.RIGHT)
+ mobController.player.velocity.x = mobController.player.speed
+ mobController.player.direction = Direction.RIGHT
} else {
- mobsController.player.velocity.x = 0f
+ mobController.player.velocity.x = 0f
}
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class JumpKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up &&
- mobsController.player.canJump() && !mobsController.player.isFlyMode &&
+ mobController.player.canJump && !mobController.player.isFlyMode &&
action.isKeyDown &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
- mobsController.player.jump()
+ mobController.player.jump()
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class MoveCursorControlsModeKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobsController: MobController,
private val gameWorld: GameWorld,
) : IKeyboardInputHandler {
else -> return
}
- player.checkCursorBounds(gameWorld);
- }
-
- companion object {
- private const val SURVIVAL_CURSOR_RANGE = 4
+ gameWorld.checkPlayerCursorBounds()
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
-import ru.deadsoftware.cavedroid.game.objects.container.ContainerController
-import ru.deadsoftware.cavedroid.game.save.GameSaveLoader
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
class PauseGameKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
private val dropController: DropController,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWorld: GameWorld,
private val containerController: ContainerController,
private val gameWindowsManager: GameWindowsManager,
+ private val saveDataRepository: SaveDataRepository,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return
}
- GameSaveLoader.save(mainConfig, dropController, mobsController, containerController, gameWorld)
+ saveDataRepository.save(mainConfig.gameFolder, dropController, mobController, containerController, gameWorld)
mainConfig.caveGame.quitGame()
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class SelectHotbarSlotKeyboardInputHandler @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
}
override fun handle(action: KeyboardInputAction) {
- mobsController.player.inventory.activeSlot = (action.actionKey as KeyboardInputActionKey.SelectHotbarSlot).slot
+ mobController.player.inventory.activeSlot = (action.actionKey as KeyboardInputActionKey.SelectHotbarSlot).slot
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class StopSwimKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
- private val gameWorld: GameWorld,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up && !action.isKeyDown &&
- mobsController.player.swim &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ mobController.player.swim &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
- mobsController.player.swim = false
+ mobController.player.swim = false
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class SwimUpKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWorld: GameWorld,
) : IKeyboardInputHandler {
private fun checkSwim(): Boolean {
- return gameWorld.getForeMap(mobsController.player.mapX, mobsController.player.lowerMapY).isFluid()
+ return gameWorld.getForeMap(mobController.player.mapX, mobController.player.lowerMapY).isFluid()
}
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up && action.isKeyDown &&
- !mobsController.player.swim &&
- !mobsController.player.canJump() &&
- checkSwim() && !mobsController.player.isFlyMode &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
+ !mobController.player.swim &&
+ !mobController.player.canJump &&
+ checkSwim() && !mobController.player.isFlyMode &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
override fun handle(action: KeyboardInputAction) {
- mobsController.player.swim = true
+ mobController.player.swim = true
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class ToggleControlsModeKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
}
override fun handle(action: KeyboardInputAction) {
- if (mobsController.player.controlMode == Player.ControlMode.WALK) {
- mobsController.player.controlMode = Player.ControlMode.CURSOR
+ if (mobController.player.controlMode == Player.ControlMode.WALK) {
+ mobController.player.controlMode = Player.ControlMode.CURSOR
} else {
- mobsController.player.controlMode = Player.ControlMode.WALK
+ mobController.player.controlMode = Player.ControlMode.WALK
}
}
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class ToggleGameModeKeyboardInputHandler @Inject constructor(
- private val mobsController: MobsController
+ private val mobController: MobController
) : IKeyboardInputHandler {
}
override fun handle(action: KeyboardInputAction) {
- if (mobsController.player.gameMode == 1) {
- mobsController.player.gameMode = 0
- } else if (mobsController.player.gameMode == 0) {
- mobsController.player.gameMode = 1
+ if (mobController.player.gameMode == 1) {
+ mobController.player.gameMode = 0
+ } else if (mobController.player.gameMode == 0) {
+ mobController.player.gameMode = 1
}
}
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
package ru.deadsoftware.cavedroid.game.input.handler.keyboard
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindKeyboardInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindKeyboardInputHandler
class TurnOnFlyModeKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobsController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return mobsController.player.gameMode == 1 && action.actionKey is KeyboardInputActionKey.Up &&
!mobsController.player.swim &&
- !mobsController.player.isFlyMode && !mobsController.player.canJump() && action.isKeyDown &&
+ !mobsController.player.isFlyMode && !mobsController.player.canJump && action.isKeyDown &&
(mobsController.player.controlMode == Player.ControlMode.WALK || !mainConfig.isTouch)
}
package ru.deadsoftware.cavedroid.game.input.handler.mouse
import com.badlogic.gdx.graphics.g2d.TextureRegion
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem.Companion.isNoneOrNull
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.AbstractInventoryWindow
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.AbstractInventoryWindowWithCraftGrid
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem.Companion.isNoneOrNull
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
abstract class AbstractInventoryItemsMouseInputHandler(
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
private val gameWindowsManager: GameWindowsManager,
private val windowType: GameUiWindow,
) : IMouseInputHandler {
}
protected fun updateCraftResult(window: AbstractInventoryWindowWithCraftGrid) {
- window.craftResult = gameItemsHolder.craftItem(window.craftingItems.map(InventoryItem::item))
- ?: gameItemsHolder.fallbackItem.toInventoryItem()
+ window.craftResult = itemsRepository.getCraftingResult(window.craftingItems.map(InventoryItem::item))
}
private fun reduceCraftItems(window: AbstractInventoryWindowWithCraftGrid) {
if (window.craftingItems[i].amount > 1) {
window.craftingItems[i].amount--
} else {
- window.craftingItems[i] = gameItemsHolder.fallbackItem.toInventoryItem()
+ window.craftingItems[i] = itemsRepository.fallbackItem.toInventoryItem()
}
}
}
) {
if (action.actionKey is MouseInputActionKey.Screen) {
if (!action.actionKey.touchUp) {
- window.onLeftCLick(items, gameItemsHolder, index, action.actionKey.pointer)
+ window.onLeftCLick(items, itemsRepository, index, action.actionKey.pointer)
} else {
if (action.actionKey.pointer == window.selectItemPointer) {
- window.onLeftCLick(items, gameItemsHolder, index, action.actionKey.pointer)
+ window.onLeftCLick(items, itemsRepository, index, action.actionKey.pointer)
} else {
- window.onRightClick(items, gameItemsHolder, index)
+ window.onRightClick(items, itemsRepository, index)
}
}
} else if (action.actionKey is MouseInputActionKey.Left) {
- window.onLeftCLick(items, gameItemsHolder, index)
+ window.onLeftCLick(items, itemsRepository, index)
} else {
- window.onRightClick(items, gameItemsHolder, index)
+ window.onRightClick(items, itemsRepository, index)
}
}
if (!selectedItem.isNoneOrNull()) {
selectedItem.amount += items[index].amount
- items[index] = gameItemsHolder.fallbackItem.toInventoryItem()
+ items[index] = itemsRepository.fallbackItem.toInventoryItem()
} else {
if (action.actionKey is MouseInputActionKey.Screen) {
if (!action.actionKey.touchUp) {
- window.onLeftCLick(items, gameItemsHolder, index, action.actionKey.pointer)
+ window.onLeftCLick(items, itemsRepository, index, action.actionKey.pointer)
}
} else if (action.actionKey is MouseInputActionKey.Left) {
- window.onLeftCLick(items, gameItemsHolder, index)
+ window.onLeftCLick(items, itemsRepository, index)
}
}
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideHotbar
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.game.world.GameWorld
+import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class AttackMouseInputHandler @Inject constructor(
- private val mobsController: MobsController,
- private val gameWorld: GameWorld,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
override fun handle(action: MouseInputAction) {
if (action.actionKey.touchUp) {
- mobsController.player.stopHitting()
+ mobController.player.stopHitting()
} else {
- mobsController.player.startHitting()
+ mobController.player.startHitting()
};
}
}
\ No newline at end of file
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.graphics.g2d.TextureRegion
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideWindow
-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.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class CloseGameWindowMouseInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val dropController: DropController,
private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
val selectedItem = gameWindowsManager.currentWindow?.selectedItem
if (selectedItem != null) {
dropController.addDrop(
- /* x = */ mobsController.player.x + (32f * mobsController.player.direction.basis),
- /* y = */ mobsController.player.y,
+ /* x = */ mobController.player.x + (32f * mobController.player.direction.basis),
+ /* y = */ mobController.player.y,
/* item = */ selectedItem.item,
/* count = */ selectedItem.amount,
)
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.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideWindow
-import ru.deadsoftware.cavedroid.misc.Assets
+import ru.deadsoftware.cavedroid.game.ui.windows.inventory.CreativeInventoryWindow
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import javax.inject.Inject
import kotlin.math.abs
class CreativeInventoryScrollMouseInputHandler @Inject constructor(
private val mainConfig: MainConfig,
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
private fun clampScrollAmount() {
gameWindowsManager.creativeScrollAmount =
- MathUtils.clamp(gameWindowsManager.creativeScrollAmount, 0, gameItemsHolder.getMaxCreativeScrollAmount())
+ MathUtils.clamp(
+ /* value = */ gameWindowsManager.creativeScrollAmount,
+ /* min = */ 0,
+ /* max = */ (gameWindowsManager.currentWindow as CreativeInventoryWindow).getMaxScroll(itemsRepository)
+ )
}
private fun handleStartOrEndDrag(action: MouseInputAction) {
import com.badlogic.gdx.math.MathUtils
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-import ru.deadsoftware.cavedroid.game.model.block.Block
import ru.deadsoftware.cavedroid.game.ui.TooltipManager
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.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
-import ru.fredboy.cavedroid.utils.bl
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.utils.bl
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByIndexUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Direction
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class CursorMouseInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWorld: GameWorld,
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
private val tooltipManager: TooltipManager,
private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getItemByIndexUseCase: GetItemByIndexUseCase,
) : IMouseInputHandler {
- private val player get() = mobsController.player
+ private val player get() = mobController.player
private val creativeInventoryTexture get() = requireNotNull(textureRegions["creative"])
}
if (player.cursorX.px + 8 < player.x + player.width / 2) {
- player.setDir(Mob.Direction.LEFT)
+ player.direction = Direction.LEFT
} else {
- player.setDir(Mob.Direction.RIGHT)
+ player.direction = Direction.RIGHT
}
}
player.headRotation = getPlayerHeadRotation(worldX, worldY)
if (worldX < player.x + player.width / 2) {
- player.setDir(Mob.Direction.LEFT)
+ player.direction = Direction.LEFT
} else {
- player.setDir(Mob.Direction.RIGHT)
+ player.direction = Direction.RIGHT
}
}
val itemIndex = (gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow +
(xOnGrid.toInt() + yOnGrid.toInt() * GameWindowsConfigs.Creative.itemsInRow))
- val item = gameItemsHolder.getItemFromCreativeInventory(itemIndex)
+ val item = getItemByIndexUseCase[itemIndex]
return item.params.name
}
!mainConfig.isTouch -> handleMouse(action)
}
- player.checkCursorBounds(gameWorld)
+ gameWorld.checkPlayerCursorBounds()
if (player.controlMode == Player.ControlMode.WALK && mainConfig.isTouch) {
setPlayerDirectionToCursor()
}
}
- companion object {
- private const val SURVIVAL_CURSOR_RANGE = 4
- }
-
}
\ No newline at end of file
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.utils.Timer
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.handler.keyboard.DropItemKeyboardInputHandler.Companion.DROP_DISTANCE
import ru.deadsoftware.cavedroid.game.input.isInsideHotbar
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-import ru.deadsoftware.cavedroid.game.model.item.Item
-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.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.drop.model.Drop
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class HotbarMouseInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val dropController: DropController,
private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
private fun createDrop(item: Item, playerX: Float, playerY: Float, amount: Int) {
dropController.addDrop(
- /* x = */ playerX + ((DROP_DISTANCE - Drop.DROP_SIZE / 2) * mobsController.player.direction.basis),
+ /* x = */ playerX + ((DROP_DISTANCE - Drop.DROP_SIZE / 2) * mobController.player.direction.basis),
/* y = */ playerY,
/* item = */ item,
/* count = */ amount
private fun handleHold(action: MouseInputAction) {
// buttonHoldTask = null
// gameWindowsManager.openInventory()
- val player = mobsController.player
+ val player = mobController.player
val actionSlot = getActionSlot(action)
val currentItem = player.inventory.items[actionSlot]
val dropAmount = if (currentItem.item.isTool()) currentItem.amount else 1
}
private fun handleUp(action: MouseInputAction) {
- mobsController.player.inventory.activeSlot = getActionSlot(action)
+ mobController.player.inventory.activeSlot = getActionSlot(action)
}
private fun handleScroll(action: MouseInputAction) {
if (action.actionKey !is MouseInputActionKey.Scroll) {
return
}
- mobsController.player.inventory.activeSlot += action.actionKey.amountY.toInt()
- if (mobsController.player.inventory.activeSlot < 0) {
- mobsController.player.inventory.activeSlot = Player.HOTBAR_SIZE - 1
- } else if (mobsController.player.inventory.activeSlot >= Player.HOTBAR_SIZE) {
- mobsController.player.inventory.activeSlot = 0
+ mobController.player.inventory.activeSlot += action.actionKey.amountY.toInt()
+ if (mobController.player.inventory.activeSlot < 0) {
+ mobController.player.inventory.activeSlot = Player.HOTBAR_SIZE - 1
+ } else if (mobController.player.inventory.activeSlot >= Player.HOTBAR_SIZE) {
+ mobController.player.inventory.activeSlot = 0
}
}
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
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.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class SelectChestInventoryItemMouseInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
-) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.CHEST) {
+ itemsRepository: ItemsRepository,
+) : AbstractInventoryItemsMouseInputHandler(itemsRepository, gameWindowsManager, GameUiWindow.CHEST) {
override val windowTexture get() = requireNotNull(textureRegions["chest"])
var itemIndex = xOnGrid + yOnGrid * GameWindowsConfigs.Chest.itemsInRow
itemIndex += GameWindowsConfigs.Chest.hotbarCells
- if (itemIndex >= mobsController.player.inventory.size) {
- itemIndex -= mobsController.player.inventory.size
+ if (itemIndex >= mobController.player.inventory.size) {
+ itemIndex -= mobController.player.inventory.size
}
- handleInsidePlaceableCell(action, mobsController.player.inventory.items, window, itemIndex)
+ handleInsidePlaceableCell(action, mobController.player.inventory.items, window, itemIndex)
}
override fun handle(action: MouseInputAction) {
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
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.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class SelectCraftingInventoryItemMouseInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
-) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.CRAFTING_TABLE) {
+ itemsRepository: ItemsRepository,
+) : AbstractInventoryItemsMouseInputHandler(itemsRepository, gameWindowsManager, GameUiWindow.CRAFTING_TABLE) {
override val windowTexture get() = requireNotNull(textureRegions["crafting_table"])
var itemIndex = xOnGrid + yOnGrid * GameWindowsConfigs.Crafting.itemsInRow
itemIndex += GameWindowsConfigs.Crafting.hotbarCells
- if (itemIndex >= mobsController.player.inventory.size) {
- itemIndex -= mobsController.player.inventory.size
+ if (itemIndex >= mobController.player.inventory.size) {
+ itemIndex -= mobController.player.inventory.size
}
- handleInsidePlaceableCell(action, mobsController.player.inventory.items, window, itemIndex)
+ handleInsidePlaceableCell(action, mobController.player.inventory.items, window, itemIndex)
}
private fun handleInsideCraft(action: MouseInputAction, xOnCraft: Int, yOnCraft: Int) {
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideWindow
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
-import ru.deadsoftware.cavedroid.misc.Assets
+import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
+import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByIndexUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class SelectCreativeInventoryItemMouseInputHandler @Inject constructor(
- private val gameItemsHolder: GameItemsHolder,
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
+ private val getItemByIndexUseCase: GetItemByIndexUseCase,
) : IMouseInputHandler {
private val creativeInventoryTexture get() = requireNotNull(textureRegions["creative"])
val itemIndex = (gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow +
(xOnGrid.toInt() + yOnGrid.toInt() * GameWindowsConfigs.Creative.itemsInRow))
- val item = gameItemsHolder.getItemFromCreativeInventory(itemIndex)
- mobsController.player.inventory.addItem(item)
+ val item = getItemByIndexUseCase[itemIndex]
+ mobController.player.inventory.addItem(item)
}
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem.Companion.isNoneOrNull
-import ru.deadsoftware.cavedroid.game.objects.container.Furnace
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.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem.Companion.isNoneOrNull
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class SelectFurnaceInventoryItemMouseInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
-) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.FURNACE) {
+ itemsRepository: ItemsRepository
+) : AbstractInventoryItemsMouseInputHandler(itemsRepository, gameWindowsManager, GameUiWindow.FURNACE) {
override val windowTexture get() = requireNotNull(textureRegions["furnace"])
var itemIndex = xOnGrid + yOnGrid * GameWindowsConfigs.Furnace.itemsInRow
itemIndex += GameWindowsConfigs.Furnace.hotbarCells
- if (itemIndex >= mobsController.player.inventory.size) {
- itemIndex -= mobsController.player.inventory.size
+ if (itemIndex >= mobController.player.inventory.size) {
+ itemIndex -= mobController.player.inventory.size
}
- handleInsidePlaceableCell(action, mobsController.player.inventory.items, window, itemIndex)
+ handleInsidePlaceableCell(action, mobController.player.inventory.items, window, itemIndex)
}
private fun handleInsideFuel(action: MouseInputAction) {
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
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.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class SelectSurvivalInventoryItemMouseInputHandler @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
-) : AbstractInventoryItemsMouseInputHandler(gameItemsHolder, gameWindowsManager, GameUiWindow.SURVIVAL_INVENTORY) {
+ private val itemsRepository: ItemsRepository,
+) : AbstractInventoryItemsMouseInputHandler(itemsRepository, gameWindowsManager, GameUiWindow.SURVIVAL_INVENTORY) {
override val windowTexture get() = requireNotNull(textureRegions["survival"])
var itemIndex = xOnGrid + yOnGrid * GameWindowsConfigs.Survival.itemsInRow
itemIndex += GameWindowsConfigs.Survival.hotbarCells
- if (itemIndex >= mobsController.player.inventory.size) {
- itemIndex -= mobsController.player.inventory.size
+ if (itemIndex >= mobController.player.inventory.size) {
+ itemIndex -= mobController.player.inventory.size
}
- handleInsidePlaceableCell(action, mobsController.player.inventory.items, window, itemIndex)
+ handleInsidePlaceableCell(action, mobController.player.inventory.items, window, itemIndex)
}
private fun handleInsideCraft(action: MouseInputAction, xOnCraft: Int, yOnCraft: Int) {
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.utils.Timer
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.actions.placeToBackgroundAction
import ru.deadsoftware.cavedroid.game.actions.placeToForegroundAction
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideHotbar
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-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.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class UseItemMouseInputHandler @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val useItemActionMap: Map<String, @JvmSuppressWildcards IUseItemAction>,
private val placeBlockActionMap: Map<String, @JvmSuppressWildcards IPlaceBlockAction>,
private val useBlockActionMap: Map<String, @JvmSuppressWildcards IUseBlockAction>,
private val gameWindowsManager: GameWindowsManager,
private val gameWorld: GameWorld,
- private val gameItemsHolder: GameItemsHolder,
private val textureRegions: GetTextureRegionByNameUseCase,
) : IMouseInputHandler {
private fun handleHold(action: MouseInputAction) {
cancelHold()
- val player = mobsController.player
+ val player = mobController.player
val item = player.inventory.activeItem.item
player.startHitting(false)
player.stopHitting()
}
private fun tryUseBlock() {
- val block = gameWorld.getForeMap(mobsController.player.cursorX, mobsController.player.cursorY)
+ val block = gameWorld.getForeMap(mobController.player.cursorX, mobController.player.cursorY)
.takeIf { !it.isNone() }
- ?: gameWorld.getBackMap(mobsController.player.cursorX, mobsController.player.cursorY)
+ ?: gameWorld.getBackMap(mobController.player.cursorX, mobController.player.cursorY)
.takeIf { !it.isNone() }
?: return
useBlockActionMap[block.params.key]?.perform(
block = block,
- x = mobsController.player.cursorX,
- y = mobsController.player.cursorY
+ x = mobController.player.cursorX,
+ y = mobController.player.cursorY
)
}
private fun handleUp(action: MouseInputAction) {
- val player = mobsController.player
+ val player = mobController.player
val item = player.inventory.activeItem.item
cancelHold()
?: Gdx.app.error(TAG, "use item action ${item.useActionKey} not found");
} else if (item is Item.Food && player.health < player.maxHealth) {
player.heal(item.heal)
- player.decreaseCurrentItemCount(gameItemsHolder)
+ player.decreaseCurrentItemCount()
} else {
tryUseBlock()
}
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.utils.TimeUtils
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.*
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-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.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Direction
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindMouseInputHandler
class JoystickInputHandler @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val gameWorld: GameWorld,
private val textureRegions: GetTextureRegionByNameUseCase,
if (!value) {
resetVelocity()
if (TimeUtils.timeSinceMillis(activateTimeMs) < 200L &&
- mobsController.player.controlMode != Player.ControlMode.CURSOR) {
- mobsController.player.jump()
+ mobController.player.controlMode != Player.ControlMode.CURSOR) {
+ mobController.player.jump()
}
} else {
activateTimeMs = TimeUtils.millis()
}
private fun resetVelocity() {
- mobsController.player.velocity.x = 0f
+ mobController.player.velocity.x = 0f
- if (mobsController.player.isFlyMode) {
- mobsController.player.velocity.y = 0f
+ if (mobController.player.isFlyMode) {
+ mobController.player.velocity.y = 0f
}
}
return
}
- val pastCursorX = mobsController.player.cursorX
- val pastCursorY = mobsController.player.cursorY
+ val pastCursorX = mobController.player.cursorX
+ val pastCursorY = mobController.player.cursorY
if (Math.abs(joystick.activeX - joystick.centerX) >= Joystick.RADIUS / 2) {
- mobsController.player.cursorX += if (joystick.activeX > joystick.centerX) 1 else -1
+ mobController.player.cursorX += if (joystick.activeX > joystick.centerX) 1 else -1
cursorTimeoutMs = TimeUtils.millis()
}
if (Math.abs(joystick.activeY - joystick.centerY) >= Joystick.RADIUS / 2) {
- mobsController.player.cursorY += if (joystick.activeY > joystick.centerY) 1 else -1
+ mobController.player.cursorY += if (joystick.activeY > joystick.centerY) 1 else -1
cursorTimeoutMs = TimeUtils.millis()
}
- mobsController.player.checkCursorBounds(gameWorld)
+ gameWorld.checkPlayerCursorBounds()
- if (mobsController.player.cursorX != pastCursorX || mobsController.player.cursorY != pastCursorY) {
- mobsController.player.blockDamage = 0f
+ if (mobController.player.cursorX != pastCursorX || mobController.player.cursorY != pastCursorY) {
+ mobController.player.blockDamage = 0f
}
}
return
}
- if (mobsController.player.controlMode == Player.ControlMode.CURSOR) {
+ if (mobController.player.controlMode == Player.ControlMode.CURSOR) {
handleCursor()
return
}
val joystick = mainConfig.joystick ?: return
val joyVector = joystick.getVelocityVector()
- if (mobsController.player.isFlyMode) {
+ if (mobController.player.isFlyMode) {
joyVector.scl(2f);
}
- mobsController.player.velocity.x = joyVector.x
+ mobController.player.velocity.x = joyVector.x
- mobsController.player.setDir(
- if (joyVector.x < 0) {
- Mob.Direction.LEFT
- } else {
- Mob.Direction.RIGHT
- }
- )
+ mobController.player.direction = if (joyVector.x < 0) {
+ Direction.LEFT
+ } else {
+ Direction.RIGHT
+ }
- if (mobsController.player.isFlyMode) {
- mobsController.player.velocity.y = joyVector.y
+ if (mobController.player.isFlyMode) {
+ mobController.player.velocity.y = joyVector.y
}
}
package ru.deadsoftware.cavedroid.game.input.mapper
import com.badlogic.gdx.Input
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.KeyboardInputActionKey
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
import com.badlogic.gdx.Input
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.mobs
-
-import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-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.fredboy.cavedroid.utils.bl
-import ru.fredboy.cavedroid.utils.px
-
-class FallingBlock(
- private val blockKey: String,
- x: Float,
- y: Float,
-) : Mob(x, y, 1.px, 1.px, Direction.RIGHT, Type.FALLING_BLOCK, Int.MAX_VALUE) {
-
- private var _block: Block? = null
-
- init {
- velocity.y = 1f
- }
-
- override fun changeDir() = Unit
-
- override fun getSpeed() = 0f
-
- override fun jump() = Unit
-
- override fun ai(
- gameWorld: GameWorld,
- gameItemsHolder: GameItemsHolder,
- mobsController: MobsController,
- delta: Float
- ) {
- if (_block == null) {
- _block = gameItemsHolder.getBlock(blockKey)
- }
-
- if (velocity.isZero) {
- gameWorld.setForeMap(x.bl, y.bl, _block)
- kill()
- }
- }
-
- override fun draw(
- spriteBatch: SpriteBatch,
- x: Float,
- y: Float,
- delta: Float
- ) {
- _block?.draw(spriteBatch, x, y)
- }
-
- override fun getSaveData(): SaveDataDto.FallingBlockSaveData {
- return SaveDataDto.FallingBlockSaveData(
- version = SAVE_DATA_VERSION,
- x = x,
- y = y,
- width = width,
- height = height,
- velocityX = velocity.x,
- velocityY = velocity.y,
- type = mType,
- animDelta = mAnimDelta,
- anim = mAnim,
- direction = mDirection,
- dead = mDead,
- canJump = mCanJump,
- flyMode = mFlyMode,
- maxHealth = mMaxHealth,
- health = mHealth,
- blockKey = blockKey,
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
-
- fun fromSaveData(saveData: SaveDataDto.FallingBlockSaveData): FallingBlock {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return FallingBlock(saveData.blockKey, saveData.x, saveData.y).apply {
- velocity.x = saveData.velocityX
- velocity.y = saveData.velocityY
- mAnimDelta = saveData.animDelta
- mAnim = saveData.anim
- mDirection = saveData.direction
- mDead = saveData.dead
- mCanJump = saveData.canJump
- mFlyMode = saveData.flyMode
- mMaxHealth = saveData.maxHealth
- mHealth = saveData.health
- }
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-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,
- getPigSprites: GetPigSpritesUseCase,
-): Mob {
- return when (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")
- }
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.mobs
-
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-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
-
-@GameScope
-class MobsController @Inject constructor(
- gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager,
- getPlayerSprites: GetPlayerSpritesUseCase,
-) : Saveable {
-
- private val _mobs = LinkedList<Mob>()
-
- var player: Player = Player(gameItemsHolder, tooltipManager, getPlayerSprites())
- private set
-
- val mobs: List<Mob>
- get() = _mobs
-
- fun addMob(mob: Mob) {
- _mobs.add(mob)
- }
-
- override fun getSaveData(): SaveDataDto.MobsControllerSaveData {
- return SaveDataDto.MobsControllerSaveData(
- version = SAVE_DATA_VERSION,
- mobs = _mobs.map(Mob::getSaveData),
- player = player.getSaveData(),
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
-
- private const val TAG = "MobsController"
-
- fun fromSaveData(
- saveData: SaveDataDto.MobsControllerSaveData,
- gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager,
- getPigSprites: GetPigSpritesUseCase,
- getPlayerSprites: GetPlayerSpritesUseCase,
- ): MobsController {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return MobsController(gameItemsHolder, tooltipManager, getPlayerSprites)
- .apply {
- _mobs.addAll(saveData.mobs.map { mob -> Mob.fromSaveData(mob, getPigSprites) })
- player = Player.fromSaveData(saveData.player, gameItemsHolder, tooltipManager, getPlayerSprites)
- }
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.mobs
-
-import com.badlogic.gdx.math.MathUtils
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.world.GameWorld
-
-abstract class PeacefulMob(x: Float, y: Float, width: Float, height: Float, direction: Direction, maxHealth: Int, )
- : Mob(x, y, width, height, direction, Type.MOB, maxHealth) {
-
- override fun ai(world: GameWorld, gameItemsHolder: GameItemsHolder, mobsController: MobsController, delta: Float) {
- if (MathUtils.randomBoolean(delta)) {
- if (velocity.x != 0f) {
- velocity.x = 0f
- } else {
- changeDir()
- }
- }
- }
-
-}
\ No newline at end of file
+++ /dev/null
-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.fredboy.cavedroid.domain.assets.model.MobSprite
-import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
-
-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
- }
-
- override fun changeDir() {
- switchDir()
- velocity = Vector2(direction.basis * speed, 0f)
- }
-
- override fun jump() {
- velocity.y = JUMP_VELOCITY
- }
-
- override fun damage(damage: Int) {
- super.damage(damage)
-
- if (damage > 0) {
- if (canJump()) {
- jump()
- }
- }
- }
-
- override fun getDrop(gameItemsHolder: GameItemsHolder): List<InventoryItem> {
- return listOf(gameItemsHolder.getItem("porkchop_raw").toInventoryItem())
- }
-
- override fun draw(
- spriteBatch: SpriteBatch,
- x: Float,
- y: Float,
- delta: Float
- ) {
- updateAnimation(delta)
-
- val leftLegX = x + sprite.getLeftLegRelativeX(direction.index)
- val rightLegX = x + sprite.getRightLegRelativeX(direction.index)
- val legY = y + sprite.getLegsRelativeY()
-
- 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 {
- return SaveDataDto.PigSaveData(
- version = SAVE_DATA_VERSION,
- x = x,
- y = y,
- width = width,
- height = height,
- velocityX = velocity.x,
- velocityY = velocity.y,
- type = mType,
- animDelta = mAnimDelta,
- anim = mAnim,
- direction = mDirection,
- dead = mDead,
- canJump = mCanJump,
- flyMode = mFlyMode,
- maxHealth = mMaxHealth,
- health = mHealth
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
-
- private const val WIDTH = 25f
- private const val HEIGHT = 18f
- private const val SPEED = 48f
- private const val JUMP_VELOCITY = -133.332f
- private const val MAX_HEALTH = 10
-
- fun fromSaveData(
- getPigSprite: GetPigSpritesUseCase,
- saveData: SaveDataDto.PigSaveData
- ): Pig {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return Pig(getPigSprite(), saveData.x, saveData.y).apply {
- velocity.x = saveData.velocityX
- velocity.y = saveData.velocityY
- mAnimDelta = saveData.animDelta
- mAnim = saveData.anim
- mDirection = saveData.direction
- mDead = saveData.dead
- mCanJump = saveData.canJump
- mFlyMode = saveData.flyMode
- mMaxHealth = saveData.maxHealth
- mHealth = saveData.health
- }
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.mobs.player
-
-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.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.objects.drop.Drop
-import ru.deadsoftware.cavedroid.game.ui.TooltipManager
-import ru.deadsoftware.cavedroid.misc.Saveable
-
-class Inventory @JvmOverloads constructor(
- val size: Int,
- val hotbarSize: Int,
- gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager,
- initialItems: List<InventoryItem>? = null
-) : Saveable {
-
- @Suppress("UNNECESSARY_LATEINIT")
- private lateinit var tooltipManager: TooltipManager
-
- @Suppress("UNNECESSARY_LATEINIT")
- private lateinit var fallbackItem: InventoryItem
-
- private val _items: Array<InventoryItem>
-
- init {
- fallbackItem = gameItemsHolder.fallbackItem.toInventoryItem()
- this.tooltipManager = tooltipManager
-
- if (size < 0 || hotbarSize < 0 || hotbarSize > size) {
- throw IllegalArgumentException("Invalid inventory sizes: hotbarSize=$hotbarSize; size=$size")
- }
-
- _items = Array(size) { index -> initialItems?.getOrNull(index) ?: InventoryItem(gameItemsHolder.fallbackItem) }
- }
-
- val items get() = _items.asList() as MutableList<InventoryItem>
-
- val hotbarItems get() = items.subList(0, hotbarSize)
-
- private var _activeSlot = 0
-
- var activeSlot
- get() = _activeSlot
- set(value) {
- if (value in 0 ..< hotbarSize) {
- _activeSlot = value
- showCurrentItemTooltip()
- }
- }
-
- fun showCurrentItemTooltip() {
- tooltipManager.showHotbarTooltip(activeItem.item.params.name)
- }
-
- val activeItem get() = _items[activeSlot]
-
- fun initItems(gameItemsHolder: GameItemsHolder, tooltipManager: TooltipManager) {
- this.tooltipManager = tooltipManager
- fallbackItem = gameItemsHolder.fallbackItem.toInventoryItem()
- _items.forEach { item ->
- item.init(gameItemsHolder)
- }
- }
-
- private fun getItemPickSlot(drop: Drop): Int {
- val item = drop.item
-
- for (i in _items.indices) {
- val inventoryItem = _items[i]
-
- if (item == inventoryItem.item && inventoryItem.canBeAdded()) {
- return i
- }
- }
-
- for (i in _items.indices) {
- val inventoryItem = _items[i]
-
- if (inventoryItem.item.isNone()) {
- return i
- }
- }
-
- return -1
- }
-
- fun canPickItem(drop: Drop): Boolean {
- return getItemPickSlot(drop) >= 0
- }
-
- fun pickDrop(drop: Drop) {
- val slot = getItemPickSlot(drop).takeIf { it >= 0 } ?: return
- val inventoryItem = _items[slot]
-
- if (inventoryItem.item == drop.item) {
- if (inventoryItem.canBeAdded(drop.amount)) {
- inventoryItem.add(drop.amount)
- drop.pickedUp = true
- } else {
- val addCount = inventoryItem.item.params.maxStack - inventoryItem.amount
- inventoryItem.add(addCount)
- drop.subtract(addCount)
- pickDrop(drop)
- }
- } else {
- _items[slot] = drop.item.toInventoryItem(drop.amount)
- if (slot == activeSlot) {
- showCurrentItemTooltip()
- }
- drop.pickedUp = true
- }
- }
-
- fun addItem(item: Item) {
- _items.copyInto(
- destination = _items,
- destinationOffset = 1,
- startIndex = 0,
- endIndex = size - 1
- )
-
- _items[0] = item.toInventoryItem(item.params.maxStack)
- showCurrentItemTooltip()
- }
-
- @JvmOverloads
- fun decreaseItemAmount(slot: Int, count: Int = 1) {
- val item = _items[slot]
- item.subtract(count)
- if (item.amount <= 0) {
- _items[slot] = fallbackItem
- }
- }
-
- @JvmOverloads
- fun decreaseCurrentItemAmount(count: Int = 1) {
- decreaseItemAmount(activeSlot, count)
- }
-
- fun clear() {
- for (i in _items.indices) {
- _items[i] = fallbackItem
- }
- }
-
- override fun getSaveData(): SaveDataDto.InventorySaveData {
- return SaveDataDto.InventorySaveData(
- version = SAVE_DATA_VERSION,
- size = size,
- hotbarSize = hotbarSize,
- activeSlot = _activeSlot,
- items = items.map(InventoryItem::getSaveData)
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
-
- fun fromSaveData(
- saveData: SaveDataDto.InventorySaveData,
- gameItemsHolder: GameItemsHolder,
- tooltipManager: TooltipManager,
- ): Inventory {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return Inventory(
- size = saveData.size,
- hotbarSize = saveData.hotbarSize,
- gameItemsHolder = gameItemsHolder,
- tooltipManager = tooltipManager,
- initialItems = saveData.items.map { item -> InventoryItem.fromSaveData(item, gameItemsHolder) }
- ).apply {
- _activeSlot = saveData.activeSlot
- }
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.model.craft
-
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
-import ru.deadsoftware.cavedroid.game.model.item.Item
-
-data class CraftingRecipe(
- val input: List<Regex>,
- val output: CraftingResult
-)
-
-data class CraftingResult(
- val item: Item,
- val amount: Int,
-) {
- fun toInventoryItem() = InventoryItem(item, amount)
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.model.mapper
-
-import com.badlogic.gdx.graphics.g2d.Sprite
-import dagger.Reusable
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.model.dto.ItemDto
-import ru.deadsoftware.cavedroid.game.model.item.CommonItemParams
-import ru.deadsoftware.cavedroid.game.model.item.Item
-import ru.deadsoftware.cavedroid.game.model.item.Item.*
-import ru.deadsoftware.cavedroid.misc.Assets
-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 {
- val params = mapCommonParams(key, dto)
-
- return when (dto.type) {
- "normal" -> Normal(params, requireNotNull(loadSprite(dto)))
- "usable" -> Usable(params, requireNotNull(loadSprite(dto)), requireNotNull(dto.actionKey))
- "shovel" -> Shovel(params, requireNotNull(loadSprite(dto)), dto.mobDamageMultiplier, dto.blockDamageMultiplier, requireNotNull(dto.toolLevel))
- "sword" -> Sword(params, requireNotNull(loadSprite(dto)), dto.mobDamageMultiplier, dto.blockDamageMultiplier, requireNotNull(dto.toolLevel))
- "pickaxe" -> Pickaxe(params, requireNotNull(loadSprite(dto)), dto.mobDamageMultiplier, dto.blockDamageMultiplier, requireNotNull(dto.toolLevel))
- "axe" -> Axe(params, requireNotNull(loadSprite(dto)), dto.mobDamageMultiplier, dto.blockDamageMultiplier, requireNotNull(dto.toolLevel))
- "shears" -> Shears(params, requireNotNull(loadSprite(dto)), dto.mobDamageMultiplier, dto.blockDamageMultiplier, requireNotNull(dto.toolLevel))
- "block" -> Block(params, requireNotNull(block))
- "slab" -> Slab(params, requireNotNull(slabTopBlock), requireNotNull(slabBottomBlock))
- "food" -> Food(params, requireNotNull(loadSprite(dto)), requireNotNull(dto.heal))
- "none" -> None(params)
- else -> throw IllegalArgumentException("Unknown item type ${dto.type}")
- }
- }
-
- private fun mapCommonParams(key: String, dto: ItemDto): CommonItemParams {
- return CommonItemParams(
- key = key,
- name = dto.name,
- inHandSpriteOrigin = SpriteOrigin(
- x = dto.originX,
- y = dto.origin_y,
- ),
- maxStack = dto.maxStack,
- burningTimeMs = dto.burningTime,
- smeltProductKey = dto.smeltProduct,
- )
- }
-
- private fun loadSprite(dto: ItemDto): Sprite? {
- if (dto.type == "none" || dto.type == "block" || dto.texture == GameItemsHolder.FALLBACK_ITEM_KEY) {
- return null
- }
-
- val texture = getItemTexture[dto.texture]
- return Sprite(texture)
- .apply {
- flip(false, true)
- dto.tint?.let {
- color = colorFromHexString(it)
- }
- }
- }
-
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.objects.container
-
-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.Saveable
-
-class Chest @JvmOverloads constructor(
- gameItemsHolder: GameItemsHolder,
- initialItems: List<InventoryItem>? = null
-) : Container(SIZE, gameItemsHolder, initialItems), Saveable {
-
- override fun update(gameItemsHolder: GameItemsHolder) {
- // no-op
- }
-
- override fun getSaveData(): SaveDataDto.ChestSaveData {
- return SaveDataDto.ChestSaveData(
- version = SAVE_DATA_VERSION,
- size = size,
- items = items.map(InventoryItem::getSaveData)
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
- private const val SIZE = 27
-
- fun fromSaveData(saveData: SaveDataDto.ChestSaveData, gameItemsHolder: GameItemsHolder): Chest {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return Chest(
- gameItemsHolder = gameItemsHolder,
- initialItems = saveData.items.map { item -> InventoryItem.fromSaveData(item, gameItemsHolder) }
- )
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.objects.container
-
-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.Saveable
-
-abstract class Container @JvmOverloads constructor(
- val size: Int,
- gameItemsHolder: GameItemsHolder,
- initialItems: List<InventoryItem>? = null,
-) : Saveable {
-
- private val _items = Array(size) { index ->
- initialItems?.getOrNull(index) ?: gameItemsHolder.fallbackItem.toInventoryItem()
- }
-
- val items get() = _items.asList() as MutableList<InventoryItem>
-
- open fun initItems(gameItemsHolder: GameItemsHolder) {
- _items.forEach { it.init(gameItemsHolder) }
- }
-
- abstract fun update(gameItemsHolder: GameItemsHolder)
-
- abstract override fun getSaveData(): SaveDataDto.ContainerSaveDataDto
-
- companion object {
- fun fromSaveData(saveData: SaveDataDto.ContainerSaveDataDto, gameItemsHolder: GameItemsHolder): Container {
- return when (saveData) {
- is SaveDataDto.FurnaceSaveData -> Furnace.fromSaveData(saveData, gameItemsHolder)
- is SaveDataDto.ChestSaveData -> Chest.fromSaveData(saveData, gameItemsHolder)
-
- is SaveDataDto.InventorySaveData -> {
- throw IllegalArgumentException("Cannot load Container from InventorySaveData")
- }
- }
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.objects.container
-
-import com.badlogic.gdx.Gdx
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
-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.fredboy.cavedroid.utils.px
-import javax.inject.Inject
-
-@GameScope
-class ContainerController @Inject constructor(
- _dropController: DropController,
- _gameItemsHolder: GameItemsHolder
-) : Saveable {
-
- @Suppress("UNNECESSARY_LATEINIT")
- private lateinit var dropController: DropController
-
- @Suppress("UNNECESSARY_LATEINIT")
- private lateinit var gameItemsHolder: GameItemsHolder
-
- private val containerMap = mutableMapOf<String, Container>()
-
- val size get() = containerMap.size
-
- init {
- dropController = _dropController
- gameItemsHolder = _gameItemsHolder
- }
-
- fun init(dropController: DropController, gameItemsHolder: GameItemsHolder) {
- this.dropController = dropController
- this.gameItemsHolder = gameItemsHolder
- containerMap.forEach { (_, container) -> container.initItems(gameItemsHolder) }
- }
-
- fun getContainer(x: Int, y: Int, z: Int): Container? {
- return containerMap["$x;$y;$z"]
- }
-
- fun addContainer(x: Int, y: Int, z: Int, clazz: Class<out Block.Container>) {
- val container = when (clazz) {
- Block.Furnace::class.java -> Furnace(gameItemsHolder)
- Block.Chest::class.java -> Chest(gameItemsHolder)
- else -> {
- Gdx.app.error(TAG, "Unknown container class $clazz")
- return
- }
- }
- containerMap["$x;$y;$z"] = container
- }
-
- @JvmOverloads
- fun destroyContainer(x: Int, y: Int, z: Int, dropItems: Boolean = true) {
- val container = containerMap.remove("$x;$y;$z") ?: return
-
- if (!dropItems) {
- return
- }
-
- val xPx = (x + .5f).px
- val yPx = (y + .5f).px
-
- container.items.forEach { item ->
- if (!item.isNoneOrNull()) {
- dropController.addDrop(xPx, yPx, item)
- }
- }
- }
-
- fun update() {
- containerMap.forEach { (_, container) ->
- container.update(gameItemsHolder)
- }
- }
-
- override fun getSaveData(): SaveDataDto.ContainerControllerSaveData {
- return SaveDataDto.ContainerControllerSaveData(
- version = SAVE_DATA_VERSION,
- containerMap = containerMap.mapValues { (_, container) -> container.getSaveData() },
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
- private const val TAG = "ContainerController"
-
- fun fromSaveData(
- saveData: SaveDataDto.ContainerControllerSaveData,
- dropController: DropController,
- gameItemsHolder: GameItemsHolder
- ): ContainerController {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return ContainerController(
- dropController,
- gameItemsHolder
- ).apply {
- containerMap.putAll(
- saveData.containerMap.mapValues { (_, containerSaveData) ->
- Container.fromSaveData(containerSaveData, gameItemsHolder)
- }
- )
- }
- }
- }
-
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.game.objects.drop
-
-import com.badlogic.gdx.math.Intersector
-import com.badlogic.gdx.math.Rectangle
-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.Item
-import ru.deadsoftware.cavedroid.misc.Saveable
-
-class Drop @JvmOverloads constructor(
- x: Float,
- y: Float,
- _item: Item,
- _amount: Int = 1,
-) : Rectangle(x, y, DROP_SIZE, DROP_SIZE), Saveable {
-
- var amount: Int = _amount
- private set
-
- val itemKey = _item.params.key
- val velocity = getInitialVelocity()
- var pickedUp = false
-
- @Suppress("UNNECESSARY_LATEINIT")
- lateinit var item: Item
- private set
-
- init {
- item = _item
- }
-
- fun initItem(gameItemsHolder: GameItemsHolder) {
- if (this::item.isInitialized) {
- return
- }
-
- item = gameItemsHolder.getItem(itemKey)
- }
-
- fun canMagnetTo(rectangle: Rectangle): Boolean {
- val magnetArea = getMagnetArea()
- return Intersector.overlaps(magnetArea, rectangle)
- }
-
- @JvmOverloads
- fun subtract(count: Int = 1) {
- if (count < 0) {
- throw IllegalArgumentException("Can't subtract negative amount")
- }
-
- amount -= count
- }
-
- private fun getMagnetArea(): Rectangle {
- return Rectangle(
- /* x = */ x - MAGNET_DISTANCE,
- /* y = */ y - MAGNET_DISTANCE,
- /* width = */ width + MAGNET_DISTANCE * 2,
- /* height = */ height + MAGNET_DISTANCE * 2,
- )
- }
-
- override fun getSaveData(): SaveDataDto.DropSaveData {
- return SaveDataDto.DropSaveData(
- version = SAVE_DATA_VERSION,
- x = x,
- y = y,
- width = width,
- height = height,
- velocityX = velocity.x,
- velocityY = velocity.y,
- itemKey = itemKey,
- amount = amount,
- pickedUp = pickedUp
- )
- }
-
- companion object {
- private const val SAVE_DATA_VERSION = 1
-
- private const val MAGNET_DISTANCE = 8f
-
- const val MAGNET_VELOCITY = 256f
- const val DROP_SIZE = 8f
-
- private fun getInitialVelocity(): Vector2 = Vector2(0f, -1f)
-
- fun fromSaveData(saveData: SaveDataDto.DropSaveData, gameItemsHolder: GameItemsHolder): Drop {
- saveData.verifyVersion(SAVE_DATA_VERSION)
-
- return Drop(
- x = saveData.x,
- y = saveData.y,
- _item = gameItemsHolder.getItem(saveData.itemKey),
- _amount = saveData.amount,
- ).apply {
- velocity.x = saveData.velocityX
- velocity.y = saveData.velocityY
- pickedUp = saveData.pickedUp
- }
- }
- }
-}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-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.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.forEachBlockInArea
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindRenderer
class BackgroundBlocksRenderer @Inject constructor(
gameWorld: GameWorld,
- mobsController: MobsController,
+ mobController: MobController,
getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
getBlockDamageSprite: GetBlockDamageSpriteUseCase
-) : BlocksRenderer(gameWorld, mobsController, getBlockDamageFrameCount, getBlockDamageSprite) {
+) : BlocksRenderer(gameWorld, mobController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.MathUtils
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.deadsoftware.cavedroid.game.world.GameWorld
-import ru.deadsoftware.cavedroid.misc.Assets
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
abstract class BlocksRenderer(
protected val gameWorld: GameWorld,
- protected val mobsController: MobsController,
+ protected val mobsController: MobController,
protected val getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
protected val getBlockDamageSprite: GetBlockDamageSpriteUseCase,
) : IGameRenderer {
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.debug.DebugInfoStringsProvider
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-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.drawString
-import ru.deadsoftware.cavedroid.misc.utils.forEachBlockInArea
+import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
-import ru.fredboy.cavedroid.utils.bl
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.utils.bl
+import ru.fredboy.cavedroid.common.utils.drawString
+import ru.fredboy.cavedroid.common.utils.forEachBlockInArea
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
class DebugRenderer @Inject constructor(
private val mainConfig: MainConfig,
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val debugInfoStringsProvider: DebugInfoStringsProvider,
private val getFont: GetFontUseCase,
) : IGameRenderer {
minimapSize: Float
) {
val mapArea = Rectangle(
- /* x = */ mobsController.player.x - (minimapSize.px / 2),
- /* y = */ mobsController.player.y - (minimapSize.px / 2),
+ /* x = */ mobController.player.x - (minimapSize.px / 2),
+ /* y = */ mobController.player.y - (minimapSize.px / 2),
/* width = */ minimapSize.px,
/* height = */ minimapSize.px
)
forEachBlockInArea(mapArea) { x, y ->
getMinimapColor(x, y)?.let { color ->
- shapeRenderer.setColor(color)
+ shapeRenderer.color = color
shapeRenderer.rect(
/* x = */ minimapX + (x - mapArea.x.bl),
/* y = */ minimapY + (y - mapArea.y.bl),
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
-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.drawSprite
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.cycledInsideWorld
+import ru.fredboy.cavedroid.common.utils.drawSprite
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-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.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.forEachBlockInArea
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindRenderer
class ForegroundBlocksRenderer @Inject constructor(
gameWorld: GameWorld,
- mobsController: MobsController,
+ mobController: MobController,
getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
getBlockDamageSprite: GetBlockDamageSpriteUseCase
-) : BlocksRenderer(gameWorld, mobsController, getBlockDamageFrameCount, getBlockDamageSprite) {
+) : BlocksRenderer(gameWorld, mobController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player
-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.annotations.multibinding.BindRenderer
-import ru.deadsoftware.cavedroid.misc.utils.drawString
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.drawString
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 ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindRenderer
class HudRenderer @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val tooltipManager: TooltipManager,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val halfHeartTexture get() = requireNotNull(textureRegions[HALF_HEART_KEY])
private fun drawCursor(spriteBatch: SpriteBatch, viewport: Rectangle) {
- val cursorX = mobsController.player.cursorX
- val cursorY = mobsController.player.cursorY
+ val cursorX = mobController.player.cursorX
+ val cursorY = mobController.player.cursorY
if (gameWorld.hasForeAt(cursorX, cursorY) ||
gameWorld.hasBackAt(cursorX, cursorY) ||
- mobsController.player.controlMode == ControlMode.CURSOR
+ mobController.player.controlMode == Player.ControlMode.CURSOR
) {
spriteBatch.draw(cursorTexture, cursorX.px - viewport.x, cursorY.px - viewport.y)
}
}
private fun drawHealth(spriteBatch: SpriteBatch, x: Float, y: Float) {
- val player = mobsController.player
+ val player = mobController.player
if (player.gameMode == 1) {
return
}
private fun drawHotbarItems(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, hotbarX: Float) {
- mobsController.player.inventory.items.asSequence().take(HotbarConfig.hotbarCells)
+ mobController.player.inventory.items.asSequence().take(HotbarConfig.hotbarCells)
.forEachIndexed { index, item ->
if (item.item.isNone()) {
return@forEachIndexed
x = hotbarX + HotbarConfig.horizontalMargin +
index * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
y = HotbarConfig.verticalMargin,
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
}
}
spriteBatch.draw(
/* region = */ hotbarSelectorTexture,
/* x = */ hotbarX - HotbarSelectorConfig.horizontalPadding
- + mobsController.player.inventory.activeSlot * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
+ + mobController.player.inventory.activeSlot * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
/* y = */ -HotbarSelectorConfig.verticalPadding
)
}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.Mob
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.world.GameWorld
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
-import ru.deadsoftware.cavedroid.misc.utils.cycledInsideWorld
-import ru.fredboy.cavedroid.utils.px
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.cycledInsideWorld
+import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Mob
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindRenderer
class MobsRenderer @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWorld: GameWorld,
) : IGameRenderer {
}
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
- val player = mobsController.player
+ val player = mobController.player
player.draw(
/* spriteBatch = */ spriteBatch,
/* x = */ player.x - viewport.x - player.width / 2,
/* delta = */ delta
)
- mobsController.mobs.forEach { mob ->
+ mobController.mobs.forEach { mob ->
drawMob(spriteBatch, viewport, mob, delta)
}
}
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.Joystick
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.mobs.player.Player.ControlMode
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.Assets
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
-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.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.drawSprite
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetTouchButtonsUseCase
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
@BindRenderer
class TouchControlsRenderer @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getTouchButtons: GetTouchButtonsUseCase,
}
// FIXME: Add pressed state for buttons
- if (mobsController.player.controlMode == ControlMode.CURSOR) {
+ if (mobController.player.controlMode == Player.ControlMode.CURSOR) {
val altKeyRect = touchControlsMap["alt"]?.rectangle ?: return
spriteBatch.draw(shadeTexture, altKeyRect.x, altKeyRect.y, altKeyRect.width, altKeyRect.height)
}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.render.windows.*
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
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.common.utils.drawSprite
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
abstract class AbstractWindowRenderer {
val itemX = gridX + (index % itemsInRow) * cellWidth
val itemY = gridY + (index / itemsInRow) * cellHeight
- inventoryItem?.draw(spriteBatch, shapeRenderer, font, itemX, itemY, getStringWidth, getStringHeight)
- ?: item?.let { spriteBatch.drawSprite(it.sprite, itemX, itemY) }
+ inventoryItem?.draw(
+ spriteBatch = spriteBatch,
+ shapeRenderer = shapeRenderer,
+ font = font,
+ x = itemX,
+ y = itemY,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke
+ ) ?: item?.let { spriteBatch.drawSprite(it.sprite, itemX, itemY) }
}
}
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
-import com.badlogic.gdx.math.MathUtils
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.Mob
-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.game.ui.windows.GameWindowsManager
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.common.di.GameScope
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.game.controller.mob.MobController
import javax.inject.Inject
-import kotlin.math.atan
@GameScope
class ChestWindowRenderer @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
font = getFont(),
gridX = windowX + GameWindowsConfigs.Chest.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Chest.itemsGridMarginTop,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.drop(GameWindowsConfigs.Chest.hotbarCells)
.take(GameWindowsConfigs.Chest.itemsInCol * GameWindowsConfigs.Chest.itemsInRow)
.asIterable(),
font = getFont(),
gridX = windowX + GameWindowsConfigs.Chest.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Chest.hotbarOffsetFromBottom,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.take(GameWindowsConfigs.Chest.hotbarCells)
.asIterable(),
itemsInRow = GameWindowsConfigs.Chest.hotbarCells,
font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
}
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.render.WindowsRenderer
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
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.common.di.GameScope
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.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
class CraftingWindowRenderer @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
font = getFont(),
gridX = windowX + GameWindowsConfigs.Crafting.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Crafting.itemsGridMarginTop,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.drop(GameWindowsConfigs.Crafting.hotbarCells)
.take(GameWindowsConfigs.Crafting.itemsInCol * GameWindowsConfigs.Crafting.itemsInRow)
.asIterable(),
font = getFont(),
gridX = windowX + GameWindowsConfigs.Crafting.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Crafting.hotbarOffsetFromBottom,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.take(GameWindowsConfigs.Crafting.hotbarCells)
.asIterable(),
itemsInRow = GameWindowsConfigs.Crafting.hotbarCells,
font = getFont(),
gridX = windowX + GameWindowsConfigs.Crafting.craftOffsetX,
gridY = windowY + GameWindowsConfigs.Crafting.craftOffsetY,
- items = window.craftingItems.asSequence().map { it ?: gameItemsHolder.fallbackItem.toInventoryItem()}.asIterable(),
+ items = window.craftingItems,
itemsInRow = GameWindowsConfigs.Crafting.craftGridSize,
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
getStringHeight = getStringHeight
)
- window.craftResult?.draw(
+ window.craftResult.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
font = getFont(),
x = windowX + GameWindowsConfigs.Crafting.craftResultOffsetX,
y = windowY + GameWindowsConfigs.Crafting.craftResultOffsetY,
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
window.selectedItem?.drawSelected(
font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-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.render.WindowsRenderer
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
+import ru.deadsoftware.cavedroid.game.ui.windows.inventory.CreativeInventoryWindow
+import ru.fredboy.cavedroid.common.di.GameScope
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.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
import kotlin.math.min
@GameScope
class CreativeWindowRenderer @Inject constructor(
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
- private val mobsController: MobsController,
+ private val itemsRepository: ItemsRepository,
+ private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
val windowX = viewport.width / 2 - creativeWindow.regionWidth / 2
val windowY = viewport.height / 2 - creativeWindow.regionHeight / 2
- val oneScrollAmount = GameWindowsConfigs.Creative.scrollIndicatorFullHeight / gameItemsHolder.getMaxCreativeScrollAmount()
+ val oneScrollAmount = GameWindowsConfigs.Creative.scrollIndicatorFullHeight /
+ (gameWindowsManager.currentWindow as CreativeInventoryWindow).getMaxScroll(itemsRepository)
spriteBatch.draw(creativeWindow, windowX, windowY)
spriteBatch.draw(
+ (gameWindowsManager.creativeScrollAmount * oneScrollAmount)
)
- val allItems = gameItemsHolder.getAllItems()
+ val allItems = itemsRepository.getAllItems()
val startIndex = gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow
val endIndex = min(startIndex + GameWindowsConfigs.Creative.itemsOnPage, allItems.size)
val items = sequence {
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(),
+ items = mobController.player.inventory.items.asSequence().take(GameWindowsConfigs.Creative.invItems).asIterable(),
itemsInRow = GameWindowsConfigs.Creative.invItems,
cellWidth = GameWindowsConfigs.Creative.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Creative.itemsGridRowHeight,
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.GameScope
-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.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.FurnaceInventoryWindow
-import ru.deadsoftware.cavedroid.misc.utils.drawSprite
-import ru.deadsoftware.cavedroid.misc.utils.withScissors
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.drawSprite
+import ru.fredboy.cavedroid.common.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 ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
class FurnaceWindowRenderer @Inject constructor(
- private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
font = getFont(),
gridX = windowX + GameWindowsConfigs.Furnace.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Furnace.itemsGridMarginTop,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.drop(GameWindowsConfigs.Furnace.hotbarCells)
.take(GameWindowsConfigs.Furnace.itemsInCol * GameWindowsConfigs.Furnace.itemsInRow)
.asIterable(),
font = getFont(),
gridX = windowX + GameWindowsConfigs.Furnace.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Furnace.hotbarOffsetFromBottom,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.take(GameWindowsConfigs.Furnace.hotbarCells)
.asIterable(),
itemsInRow = GameWindowsConfigs.Furnace.hotbarCells,
getStringHeight = getStringHeight
)
- window.furnace.fuel?.draw(
+ window.furnace.fuel.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
font = getFont(),
x = windowX + GameWindowsConfigs.Furnace.smeltFuelMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.smeltFuelMarginTop,
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
- window.furnace.input?.draw(
+ window.furnace.input.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
font = getFont(),
x = windowX + GameWindowsConfigs.Furnace.smeltInputMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.smeltInputMarginTop,
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
- window.furnace.result?.draw(
+ window.furnace.result.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
font = getFont(),
x = windowX + GameWindowsConfigs.Furnace.smeltResultOffsetX,
y = windowY + GameWindowsConfigs.Furnace.smeltResultOffsetY,
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
if (window.furnace.isActive) {
val burn = GameWindowsConfigs.Furnace.fuelBurnHeight * window.furnace.burnProgress
spriteBatch.withScissors(
- mainConfig = mainConfig,
x = windowX + GameWindowsConfigs.Furnace.fuelBurnMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.fuelBurnMarginTop + burn,
width = furnaceBurn.width,
height = GameWindowsConfigs.Furnace.fuelBurnHeight,
+ viewportWidth = viewport.width,
+ viewportHeight = viewport.height,
) {
spriteBatch.drawSprite(
sprite = furnaceBurn,
val progress = GameWindowsConfigs.Furnace.progressWidth * window.furnace.smeltProgress
spriteBatch.withScissors(
- mainConfig = mainConfig,
x = windowX + GameWindowsConfigs.Furnace.progressMarginLeft,
y = windowY + GameWindowsConfigs.Furnace.progressMarginTop,
width = progress,
- height = furnaceProgress.height
+ height = furnaceProgress.height,
+ viewportWidth = viewport.width,
+ viewportHeight = viewport.height,
) {
spriteBatch.drawSprite(
sprite = furnaceProgress,
font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
}
import com.badlogic.gdx.math.MathUtils
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.Mob
-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.game.ui.windows.GameWindowsManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.SurvivalInventoryWindow
-import ru.deadsoftware.cavedroid.misc.Assets
+import ru.fredboy.cavedroid.common.di.GameScope
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.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.model.Direction
import javax.inject.Inject
import kotlin.math.atan
@GameScope
class SurvivalWindowRenderer @Inject constructor(
private val mainConfig: MainConfig,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
val h = mouseX.toDouble() - portraitX.toDouble()
val v = mouseY.toDouble() - portraitY.toDouble()
- mobsController.player.setDir(
- if (mouseX < portraitX + mobsController.player.width / 2)
- Mob.Direction.LEFT
- else
- Mob.Direction.RIGHT
- )
+ mobController.player.direction = if (mouseX < portraitX + mobController.player.width / 2) {
+ Direction.LEFT
+ } else {
+ Direction.RIGHT
+ }
- mobsController.player.headRotation = atan(v / h).toFloat() * MathUtils.radDeg
+ mobController.player.headRotation = atan(v / h).toFloat() * MathUtils.radDeg
}
private fun drawPlayerPortrait(spriteBatch: SpriteBatch, windowX: Float, windowY: Float, delta: Float) {
val portraitX = windowX + GameWindowsConfigs.Survival.portraitMarginLeft +
- (GameWindowsConfigs.Survival.portraitWidth / 2 - mobsController.player.width / 2)
+ (GameWindowsConfigs.Survival.portraitWidth / 2 - mobController.player.width / 2)
val portraitY = windowY + GameWindowsConfigs.Survival.portraitMarginTop +
- (GameWindowsConfigs.Survival.portraitHeight / 2 - mobsController.player.height / 2)
+ (GameWindowsConfigs.Survival.portraitHeight / 2 - mobController.player.height / 2)
setPortraitHeadRotation(portraitX, portraitY)
- mobsController.player.draw(spriteBatch, portraitX, portraitY, delta)
+ mobController.player.draw(spriteBatch, portraitX, portraitY, delta)
}
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
font = getFont(),
gridX = windowX + GameWindowsConfigs.Survival.itemsGridMarginLeft,
gridY = windowY + GameWindowsConfigs.Survival.itemsGridMarginTop,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.drop(GameWindowsConfigs.Survival.hotbarCells)
.take(GameWindowsConfigs.Survival.itemsInCol * GameWindowsConfigs.Survival.itemsInRow)
.asIterable(),
font = getFont(),
gridX = windowX + GameWindowsConfigs.Survival.itemsGridMarginLeft,
gridY = windowY + windowTexture.regionHeight - GameWindowsConfigs.Survival.hotbarOffsetFromBottom,
- items = mobsController.player.inventory.items.asSequence()
+ items = mobController.player.inventory.items.asSequence()
.take(GameWindowsConfigs.Survival.hotbarCells)
.asIterable(),
itemsInRow = GameWindowsConfigs.Survival.hotbarCells,
if (index % 3 > 1 || index / 3 > 1) {
null
} else {
- it ?: gameItemsHolder.fallbackItem.toInventoryItem()
+ it
}
}.asIterable(),
itemsInRow = GameWindowsConfigs.Survival.craftGridSize,
getStringHeight = getStringHeight
)
- window.craftResult?.draw(
+ window.craftResult.draw(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
font = getFont(),
x = windowX + GameWindowsConfigs.Survival.craftResultOffsetX,
y = windowY + GameWindowsConfigs.Survival.craftResultOffsetY,
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
window.selectedItem?.drawSelected(
font = getFont(),
x = Gdx.input.x * (viewport.width / Gdx.graphics.width),
y = Gdx.input.y * (viewport.height / Gdx.graphics.height),
- getStringWidth = getStringWidth,
- getStringHeight = getStringHeight,
+ getStringWidth = getStringWidth::invoke,
+ getStringHeight = getStringHeight::invoke,
)
}
package ru.deadsoftware.cavedroid.game.ui
import com.badlogic.gdx.utils.Timer
-import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
+import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
@GameScope
-class TooltipManager @Inject constructor(
- private val mainConfig: MainConfig
-) {
+class TooltipManager @Inject constructor() {
private val resetTask = object : Timer.Task() {
override fun run() {
package ru.deadsoftware.cavedroid.game.ui.windows
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.objects.container.Chest
-import ru.deadsoftware.cavedroid.game.objects.drop.DropController
-import ru.deadsoftware.cavedroid.game.objects.container.Furnace
import ru.deadsoftware.cavedroid.game.ui.TooltipManager
import ru.deadsoftware.cavedroid.game.ui.windows.inventory.*
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.container.model.Chest
+import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@GameScope
class GameWindowsManager @Inject constructor(
private val tooltipManager: TooltipManager,
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val dropController: DropController,
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
) {
var creativeScrollAmount = 0
}
fun openInventory() {
- if (mobsController.player.gameMode == 1) {
+ if (mobController.player.gameMode == 1) {
currentWindow = CreativeInventoryWindow()
} else {
- currentWindow = SurvivalInventoryWindow(gameItemsHolder)
+ currentWindow = SurvivalInventoryWindow(itemsRepository)
}
}
}
fun openCrafting() {
- currentWindow = CraftingInventoryWindow(gameItemsHolder)
+ currentWindow = CraftingInventoryWindow(itemsRepository)
}
fun closeWindow() {
(currentWindow as? AbstractInventoryWindowWithCraftGrid)?.let { window ->
window.craftingItems.forEach { item ->
- dropController.addDrop(mobsController.player.x, mobsController.player.y, item)
+ dropController.addDrop(mobController.player.x, mobController.player.y, item)
}
}
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import com.badlogic.gdx.math.MathUtils
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem.Companion.isNoneOrNull
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem.Companion.isNoneOrNull
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
abstract class AbstractInventoryWindow {
fun onLeftCLick(
items: MutableList<InventoryItem>,
- gameItemsHolder: GameItemsHolder,
+ itemsRepository: ItemsRepository,
index: Int,
pointer: Int = -1
) {
}
val item = items[index]
- items[index] = selectedItem ?: gameItemsHolder.fallbackItem.toInventoryItem()
+ items[index] = selectedItem ?: itemsRepository.fallbackItem.toInventoryItem()
selectedItem = item
selectItemPointer = pointer
}
- fun onRightClick(items: MutableList<InventoryItem>, gameItemsHolder: GameItemsHolder, index: Int) {
+ fun onRightClick(items: MutableList<InventoryItem>, itemsRepository: ItemsRepository, index: Int) {
val clickedItem = items[index]
val selectedItem = selectedItem
this.selectedItem = half
clickedItem.subtract(half.amount)
if (clickedItem.amount == 0) {
- items[index] = gameItemsHolder.fallbackItem.toInventoryItem()
+ items[index] = itemsRepository.fallbackItem.toInventoryItem()
}
return
}
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
abstract class AbstractInventoryWindowWithCraftGrid(
- gameItemsHolder: GameItemsHolder,
+ itemsRepository: ItemsRepository,
) : AbstractInventoryWindow() {
- private val _items = Array(10) { gameItemsHolder.fallbackItem.toInventoryItem() }
+ private val _items = Array(10) { itemsRepository.fallbackItem.toInventoryItem() }
val items get() = _items.asList()
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
-import ru.deadsoftware.cavedroid.game.objects.container.Chest
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.game.controller.container.model.Chest
class ChestInventoryWindow(val chest: Chest) : AbstractInventoryWindow() {
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
class CraftingInventoryWindow(
- gameItemsHolder: GameItemsHolder
-) : AbstractInventoryWindowWithCraftGrid(gameItemsHolder) {
+ itemsRepository: ItemsRepository
+) : AbstractInventoryWindowWithCraftGrid(itemsRepository) {
override val type = GameUiWindow.CRAFTING_TABLE
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
+import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
class CreativeInventoryWindow() : AbstractInventoryWindow() {
override val type = GameUiWindow.CREATIVE_INVENTORY
override var selectedItem: InventoryItem? = null
+
+ fun getMaxScroll(itemsRepository: ItemsRepository): Int {
+ return itemsRepository.getAllItems().size / GameWindowsConfigs.Creative.itemsInRow
+ }
}
\ No newline at end of file
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
-import ru.deadsoftware.cavedroid.game.objects.container.Furnace
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.game.controller.container.model.Furnace
class FurnaceInventoryWindow(
val furnace: Furnace,
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.deadsoftware.cavedroid.game.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
class SurvivalInventoryWindow(
- gameItemsHolder: GameItemsHolder
-) : AbstractInventoryWindowWithCraftGrid(gameItemsHolder) {
+ itemsRepository: ItemsRepository
+) : AbstractInventoryWindowWithCraftGrid(itemsRepository) {
override val type = GameUiWindow.SURVIVAL_INVENTORY
package ru.deadsoftware.cavedroid.game.world
import com.badlogic.gdx.utils.Timer.Task
-import ru.deadsoftware.cavedroid.game.GameScope
import ru.deadsoftware.cavedroid.game.actions.getRequiresBlockAction
import ru.deadsoftware.cavedroid.game.actions.updateblock.IUpdateBlockAction
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
class GameWorldBlocksLogicControllerTask @Inject constructor(
private val gameWorld: GameWorld,
private val updateBlockActions: Map<String, @JvmSuppressWildcards IUpdateBlockAction>,
- private val mobsController: MobsController,
+ private val mobController: MobController,
) : Task() {
private var currentRelativeChunk = 0
private fun getChunkStart(): Int {
- val playerX = mobsController.player.mapX
+ val playerX = mobController.player.mapX
val playerChunk = playerX / CHUNK_WIDTH
val currentChunk = playerChunk - CHUNKS / 2 + currentRelativeChunk
package ru.deadsoftware.cavedroid.game.world
import com.badlogic.gdx.utils.Timer
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.game.model.block.Block
-import ru.fredboy.cavedroid.utils.bl
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.bl
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import java.util.PriorityQueue
import javax.inject.Inject
import kotlin.math.min
@GameScope
class GameWorldFluidsLogicControllerTask @Inject constructor(
private val gameWorld: GameWorld,
- private val mobsController: MobsController,
- private val gameItemsHolder: GameItemsHolder,
+ private val mobController: MobController,
+ private val itemsRepository: ItemsRepository,
) : Timer.Task() {
private var updateTick: Short = 0;
}
init {
- val waters = gameItemsHolder.getBlocksByType(Block.Water::class.java)
+ val waters = itemsRepository.getBlocksByType(Block.Water::class.java)
.sortedBy(Block.Water::state)
- val lavas = gameItemsHolder.getBlocksByType(Block.Lava::class.java)
+ val lavas = itemsRepository.getBlocksByType(Block.Lava::class.java)
.sortedBy(Block.Lava::state)
fluidStatesMap[Block.Water::class] = waters
fluidCanFlowThere(currentFluid, targetBlock) -> UpdateCommand(nextStateFluid, x, y)
currentFluid.isWater() && targetBlock is Block.Lava && targetBlock.state > 0 ->
- UpdateCommand(100) { gameWorld.setForeMap(x, y, gameItemsHolder.getBlock("cobblestone")) }
+ UpdateCommand(100) { gameWorld.setForeMap(x, y, itemsRepository.getBlockByKey("cobblestone")) }
currentFluid.isWater() && targetBlock.isLava() ->
- UpdateCommand(100) { gameWorld.setForeMap(x, y, gameItemsHolder.getBlock("obsidian")) }
+ UpdateCommand(100) { gameWorld.setForeMap(x, y, itemsRepository.getBlockByKey("obsidian")) }
currentFluid.isLava() && targetBlock.isWater() ->
- UpdateCommand(200) { gameWorld.setForeMap(x, y, gameItemsHolder.getBlock("stone")) }
+ UpdateCommand(200) { gameWorld.setForeMap(x, y, itemsRepository.getBlockByKey("stone")) }
else -> null
}
}
private fun fluidUpdater() {
- val midScreen = mobsController.player.x.bl
+ val midScreen = mobController.player.x.bl
for (y in gameWorld.height - 1 downTo 0) {
for (x in 0 ..< min(gameWorld.width / 2, 32)) {
package ru.deadsoftware.cavedroid.game.world
import com.badlogic.gdx.utils.Timer
-import ru.deadsoftware.cavedroid.game.GameItemsHolder
-import ru.deadsoftware.cavedroid.game.GameScope
-import ru.deadsoftware.cavedroid.game.mobs.MobsController
-import ru.deadsoftware.cavedroid.misc.utils.forEachBlockInArea
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.forEachBlockInArea
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
import kotlin.math.max
@GameScope
class GameWorldMobDamageControllerTask @Inject constructor(
- private val mobsController: MobsController,
+ private val mobController: MobController,
private val gameWorld: GameWorld,
- private val gameItemsHolder: GameItemsHolder,
+ private val itemsRepository: ItemsRepository,
) : Timer.Task() {
override fun run() {
sequence {
- yield(mobsController.player)
- yieldAll(mobsController.mobs)
+ yield(mobController.player)
+ yieldAll(mobController.mobs)
}.forEach { mob ->
forEachBlockInArea(mob) { x, y ->
val foregroundBlock = gameWorld.getForeMap(x, y)
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
import javax.inject.Inject
@MenuScope
private val mainConfig: MainConfig,
private val assetLoader: AssetLoader,
private val getTextureRegionByName: GetTextureRegionByNameUseCase,
+ private val saveDataRepository: SaveDataRepository,
) {
fun getMainMenu(
buttonRenderer: ButtonRenderer,
menuInput: MenuProc.Input,
): MenuMain {
- return MenuMain(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName)
+ return MenuMain(
+ width,
+ height,
+ buttonRenderer,
+ mainConfig,
+ menuInput,
+ assetLoader,
+ getTextureRegionByName,
+ saveDataRepository
+ ).apply { init() }
}
fun getMenuNewGame(
buttonRenderer: ButtonRenderer,
menuInput: MenuProc.Input,
): MenuNewGame {
- return MenuNewGame(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName)
+ return MenuNewGame(
+ width,
+ height,
+ buttonRenderer,
+ mainConfig,
+ menuInput,
+ assetLoader,
+ getTextureRegionByName
+ ).apply { init() }
}
fun getMenuOptions(
buttonRenderer: ButtonRenderer,
menuInput: MenuProc.Input,
): MenuOptions {
- return MenuOptions(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByName)
+ return MenuOptions(
+ width,
+ height,
+ buttonRenderer,
+ mainConfig,
+ menuInput,
+ assetLoader,
+ getTextureRegionByName
+ ).apply { init() }
}
}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.misc
-
-import ru.deadsoftware.cavedroid.game.model.dto.SaveDataDto
-
-interface Saveable {
- fun getSaveData(): SaveDataDto
-}
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.input.IKeyboardInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoSet
@BindsIntoSet(
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoSet
@BindsIntoSet(
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.actions.placeblock.IPlaceBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoMapStringKey
@BindsIntoMapStringKey(
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.render.IGameRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoSet
@BindsIntoSet(
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.actions.updateblock.IUpdateBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoMapStringKey
@BindsIntoMapStringKey(
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.actions.useblock.IUseBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoMapStringKey
@BindsIntoMapStringKey(
package ru.deadsoftware.cavedroid.misc.annotations.multibinding
import ru.deadsoftware.cavedroid.game.actions.useitem.IUseItemAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
import ru.fredboy.automultibind.annotations.BindsIntoMapStringKey
@BindsIntoMapStringKey(
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
data object MultibindingConfig {
const val GENERATED_MODULES_PACKAGE = "ru.deadsoftware.cavedroid.generated.module"
+++ /dev/null
-package ru.deadsoftware.cavedroid.misc.utils
-
-import com.badlogic.gdx.utils.ObjectMap
-
-object ArrayMapExtensions {
- operator fun <K, V> ObjectMap.Entry<K, V>.component1(): K = this.key
-
- operator fun <K, V> ObjectMap.Entry<K, V>.component2(): V = this.value
-}
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.files.FileHandle
import ru.deadsoftware.cavedroid.MainConfig
-import ru.deadsoftware.cavedroid.game.GameScope
import java.io.File
import javax.inject.Inject
import javax.inject.Singleton
+++ /dev/null
-package ru.deadsoftware.cavedroid.misc.utils
-
-import com.badlogic.gdx.Graphics
-
-val Graphics.ratio get() = width.toFloat() / height.toFloat()
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid.misc.utils
-
-import ru.deadsoftware.cavedroid.game.GameItemsHolder.Companion.FALLBACK_ITEM_KEY
-import ru.deadsoftware.cavedroid.game.model.item.Item
-
-fun Item.isFallback(): Boolean {
- return this.params.key == FALLBACK_ITEM_KEY
-}
include("desktop")
include("core")
-include("core:base")
+/**
+ * Global modules
+ */
+include("core:common")
// data modules
include("core:data:assets")
+include("core:data:items")
+include("core:data:save")
-//domain modules
+// domain modules
include("core:domain:assets")
+include("core:domain:items")
+include("core:domain:save")
+
+/**
+ * Game scope modules
+ */
+include("core:game")
+
+// controller modules
+include("core:game:controller:drop")
+include("core:game:controller:container")
+include("core:game:controller:mob")
+
+// world module
+include("core:game:world")
