// domain
useModule(":core:domain:assets")
useModule(":core:domain:items")
+ useModule(":core:domain:world")
useModule(":core:domain:save")
+ //entity
+ useModule(":core:entity:container")
+ useModule(":core:entity:drop")
+ useModule(":core:entity:mob")
+
// controller
useModule(":core:game:controller:drop")
useModule(":core:game:controller:container")
--- /dev/null
+package ru.fredboy.cavedroid.common.utils
+
+fun <T> MutableCollection<T>.retrieveFirst(predicate: (T) -> Boolean): T? {
+ val iterator = this.iterator()
+ while (iterator.hasNext()) {
+ val element = iterator.next()
+ if (predicate.invoke(element)) {
+ iterator.remove()
+ return element
+ }
+ }
+
+ return null
+}
+
+fun <T> MutableCollection<T>.removeFirst(predicate: (T) -> Boolean): Boolean {
+ return retrieveFirst(predicate) != null
+}
\ No newline at end of file
flush()
Gdx.gl.glDisable(GL20.GL_SCISSOR_TEST)
}
+
+fun Int.blockCenterPx() = (toFloat() + .5f).px
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.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import java.util.*
useModule(":core:domain:assets")
useModule(":core:domain:items")
+ useModule(":core:domain:world")
useModule(":core:domain:save")
+ useModule(":core:entity:container")
+ useModule(":core:entity:drop")
+ useModule(":core:entity:mob")
+
useModule(":core:game:controller:container")
useModule(":core:game:controller:drop")
useModule(":core:game:controller:mob")
+
useModule(":core:game:world")
}
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 ru.fredboy.cavedroid.entity.container.model.Chest
import javax.inject.Inject
@Reusable
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 ru.fredboy.cavedroid.entity.container.model.Chest
+import ru.fredboy.cavedroid.entity.container.model.ContainerCoordinates
+import ru.fredboy.cavedroid.entity.container.model.Furnace
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
import javax.inject.Inject
@Reusable
private val getItemByKeyUseCase: GetItemByKeyUseCase,
) {
- fun mapSaveData(containerController: ContainerControllerImpl): SaveDataDto.ContainerControllerSaveDataDto {
+ fun mapSaveData(containerController: ContainerController): SaveDataDto.ContainerControllerSaveDataDto {
return SaveDataDto.ContainerControllerSaveDataDto(
version = SAVE_DATA_VERSION,
containerMap = containerController.containerMap.mapNotNull { (key, container) ->
is Furnace -> furnaceMapper.mapSaveData(container)
is Chest -> chestMapper.mapSaveData(container)
else -> null
- }?.let { value -> key to value }
+ }?.let { value -> key.toString() to value }
}.toMap()
)
}
- fun mapContainerController(saveDataDto: SaveDataDto.ContainerControllerSaveDataDto): ContainerControllerImpl {
+ fun mapContainerController(saveDataDto: SaveDataDto.ContainerControllerSaveDataDto): ContainerController {
saveDataDto.verifyVersion(SAVE_DATA_VERSION)
- return ContainerControllerImpl(getItemByKeyUseCase).apply {
+ return ContainerController(
+ getItemByKeyUseCase = getItemByKeyUseCase,
+ containerWorldAdapter = TODO("containerWorldAdapter"),
+ containerFactory = TODO("ContainerFactory"),
+ dropAdapter = TODO("DropAdapter")
+ ).apply {
saveDataDto.containerMap.forEach { (key, value) ->
val container = when (value) {
is SaveDataDto.FurnaceSaveDataDto -> furnaceMapper.mapFurnace(value)
}
if (container != null) {
- containerMap.put(key, container)
+ containerMap.put(ContainerCoordinates.fromString(key), container)
}
}
}
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 ru.fredboy.cavedroid.entity.mob.model.Player
import javax.inject.Inject
@Reusable
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 ru.fredboy.cavedroid.entity.mob.model.Direction
import javax.inject.Inject
@Reusable
import dagger.Reusable
import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
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
+ private val dropMapper: DropMapper,
+ private val itemsRepository: ItemsRepository
) {
fun mapSaveData(dropController: DropController): SaveDataDto.DropControllerSaveDataDto {
fun mapDropController(saveDataDto: SaveDataDto.DropControllerSaveDataDto): DropController {
saveDataDto.verifyVersion(SAVE_DATA_VERSION)
- return DropControllerImpl(
- initialDrop = saveDataDto.drops.map(dropMapper::mapDrop)
+ return DropController(
+ initialDrop = saveDataDto.drops.map(dropMapper::mapDrop),
+ dropWorldAdapter = TODO("dropWorldAdapter"),
+ itemsRepository = itemsRepository,
)
}
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 ru.fredboy.cavedroid.entity.drop.model.Drop
import javax.inject.Inject
@Reusable
x = saveDataDto.x,
y = saveDataDto.y,
item = getItemByKeyUseCase[saveDataDto.itemKey],
- _amount = saveDataDto.amount
+ amount = saveDataDto.amount
).apply {
width = saveDataDto.width
height = saveDataDto.height
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 ru.fredboy.cavedroid.entity.mob.model.FallingBlock
+import ru.fredboy.cavedroid.game.controller.mob.behavior.FallingBlockMobBehavior
import javax.inject.Inject
@Reusable
return FallingBlock(
block = getBlockByKeyUseCase[saveDataDto.blockKey],
x = saveDataDto.x,
- y = saveDataDto.y
+ y = saveDataDto.y,
+ behavior = FallingBlockMobBehavior(),
).apply {
width = saveDataDto.width
height = saveDataDto.height
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 ru.fredboy.cavedroid.entity.container.model.Furnace
import javax.inject.Inject
@Reusable
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.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
import javax.inject.Inject
import dagger.Reusable
import ru.fredboy.cavedroid.data.save.model.SaveDataDto
+import ru.fredboy.cavedroid.domain.items.model.inventory.Inventory
import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
-import ru.fredboy.cavedroid.game.controller.mob.model.Inventory
import javax.inject.Inject
@Reusable
return SaveDataDto.InventorySaveDataDto(
version = SAVE_DATA_VERSION,
size = inventory.size,
- hotbarSize = inventory.hotbarSize,
- activeSlot = inventory.activeSlot,
items = inventory.items.map(inventoryItemMapper::mapSaveData)
)
}
return Inventory(
size = saveDataDto.size,
- hotbarSize = saveDataDto.hotbarSize,
fallbackItem = getFallbackItem(),
initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem)
- ).apply {
- activeSlot = saveDataDto.activeSlot
- }
+ )
}
companion object {
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 ru.fredboy.cavedroid.entity.mob.model.FallingBlock
+import ru.fredboy.cavedroid.entity.mob.model.Pig
+import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
@Reusable
private val getFallbackItemUseCase: GetFallbackItemUseCase,
) {
- fun mapSaveData(mobController: MobControllerImpl): SaveDataDto.MobControllerSaveDataDto {
+ fun mapSaveData(mobController: MobController): SaveDataDto.MobControllerSaveDataDto {
return SaveDataDto.MobControllerSaveDataDto(
version = SAVE_DATA_VERSION,
mobs = mobController.mobs.mapNotNull { mob ->
)
}
- fun mapMobController(saveDataDto: SaveDataDto.MobControllerSaveDataDto): MobControllerImpl {
+ fun mapMobController(saveDataDto: SaveDataDto.MobControllerSaveDataDto): MobController {
saveDataDto.verifyVersion(SAVE_DATA_VERSION)
- return MobControllerImpl(
+ return MobController(
mobAssetsRepository = mobAssetsRepository,
- getFallbackItemUseCase = getFallbackItemUseCase
+ getFallbackItemUseCase = getFallbackItemUseCase,
+ mobWorldAdapter = TODO("mobWorldAdapter"),
).apply {
(mobs as MutableList).addAll(saveDataDto.mobs.mapNotNull { mob ->
when (mob) {
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 ru.fredboy.cavedroid.entity.mob.model.Pig
+import ru.fredboy.cavedroid.game.controller.mob.behavior.PigMobBehavior
import javax.inject.Inject
@Reusable
return Pig(
sprite = getPigSpriteUseCase(),
x = saveDataDto.x,
- y = saveDataDto.y
+ y = saveDataDto.y,
+ behavior = PigMobBehavior(),
).apply {
width = saveDataDto.width
height = saveDataDto.height
package ru.fredboy.cavedroid.data.save.mapper
+import com.badlogic.gdx.math.Vector2
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 ru.fredboy.cavedroid.entity.mob.model.Player
+import ru.fredboy.cavedroid.game.controller.mob.behavior.PlayerMobBehavior
import javax.inject.Inject
@Reusable
blockDamage = player.blockDamage,
cursorX = player.cursorX,
cursorY = player.cursorY,
- spawnPointX = 0f,
- spawnPointY = 0f,
- controlMode = controlModeMapper.mapSaveData(player.controlMode)
+ spawnPointX = player.spawnPoint?.x ?: 0f,
+ spawnPointY = player.spawnPoint?.y ?: 0f,
+ controlMode = controlModeMapper.mapSaveData(player.controlMode),
+ activeSlot = player.activeSlot,
)
}
sprite = getPlayerSpritesUseCase(),
getFallbackItem = getFallbackItemUseCase,
x = saveDataDto.x,
- y = saveDataDto.y
+ y = saveDataDto.y,
+ behavior = PlayerMobBehavior()
).apply {
width = saveDataDto.width
height = saveDataDto.height
cursorX = saveDataDto.cursorX
cursorY = saveDataDto.cursorY
controlMode = controlModeMapper.mapControlMode(saveDataDto.controlMode)
+ spawnPoint = Vector2(saveDataDto.spawnPointX, saveDataDto.spawnPointY)
+ activeSlot = saveDataDto.activeSlot
}
}
data class InventorySaveDataDto(
override val version: Int,
override val size: Int,
- val hotbarSize: Int,
- val activeSlot: Int,
override val items: List<InventoryItemSaveDataDto>,
) : ContainerSaveDataDto()
val spawnPointX: Float,
val spawnPointY: Float,
val controlMode: ControlModeSaveDataDto,
+ val activeSlot: Int,
) : MobSaveDataDto()
@Serializable
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
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))
+ val dropBytes = ProtoBuf.encodeToByteArray(dropControllerMapper.mapSaveData(dropController as DropController))
+ val mobsBytes = ProtoBuf.encodeToByteArray(mobControllerMapper.mapSaveData(mobController as MobController))
+ val containersBytes = ProtoBuf.encodeToByteArray(containerControllerMapper.mapSaveData(containerController as ContainerController))
dropFile.writeBytes(dropBytes, false)
mobsFile.writeBytes(mobsBytes, false)
package ru.fredboy.cavedroid.domain.items.model.craft
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
data class CraftingResult(
-package ru.fredboy.cavedroid.game.controller.mob.model
+package ru.fredboy.cavedroid.domain.items.model.inventory
-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() }
+ private val _items: Array<InventoryItem> = 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]
_items[0] = item.toInventoryItem(item.params.maxStack)
}
+ /**
+ * @return true if all amount was picked up
+ */
+ fun pickUpItem(pickingItem: InventoryItem): Boolean {
+ val slot = getAvailableSlotForItem(pickingItem.item).takeIf { it >= 0 } ?: return false
+ val inventoryItem = _items[slot]
+
+ if (inventoryItem.item == pickingItem.item) {
+ if (inventoryItem.canBeAdded(pickingItem.amount)) {
+ inventoryItem.add(pickingItem.amount)
+ return true
+ } else {
+ val addCount = inventoryItem.item.params.maxStack - inventoryItem.amount
+ inventoryItem.add(addCount)
+ pickingItem.subtract(addCount)
+ return false
+ }
+ } else {
+ _items[slot] = pickingItem
+ return true
+ }
+ }
+
@JvmOverloads
fun decreaseItemAmount(slot: Int, count: Int = 1) {
val item = _items[slot]
}
}
- @JvmOverloads
- fun decreaseCurrentItemAmount(count: Int = 1) {
- decreaseItemAmount(activeSlot, count)
- }
-
fun clear() {
for (i in _items.indices) {
_items[i] = fallbackItem.toInventoryItem()
-package ru.fredboy.cavedroid.domain.items.model.item
+package ru.fredboy.cavedroid.domain.items.model.inventory
import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.g2d.BitmapFont
import ru.fredboy.cavedroid.common.utils.drawSprite
import ru.fredboy.cavedroid.common.utils.drawString
import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.items.model.item.Item
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
package ru.fredboy.cavedroid.domain.items.model.item
import com.badlogic.gdx.graphics.g2d.Sprite
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
import ru.fredboy.cavedroid.domain.items.model.block.Block as DomainBlockModel
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.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
interface ItemsRepository : Disposable {
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.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import javax.inject.Inject
--- /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 GetFallbackBlockUseCase @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+) {
+
+ operator fun invoke(): Block.None {
+ return itemsRepository.fallbackBlock
+ }
+
+}
\ No newline at end of file
useModule(":core:domain:items")
useModule(":core:domain:assets")
+ useModule(":core:domain:world")
useModule(":core:game:controller:container")
useModule(":core:game:controller:drop")
--- /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.domain.world.listener
+
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.world.model.Layer
+
+fun interface OnBlockDestroyedListener {
+
+ fun onBlockDestroyed(block: Block, x: Int, y: Int, layer: Layer, withDrop: Boolean)
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.world.listener
+
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.world.model.Layer
+
+fun interface OnBlockPlacedListener {
+
+ fun onBlockPlaced(block: Block, x: Int, y: Int, layer: Layer)
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.domain.world.model
+
+enum class Layer(val z: Int) {
+ FOREGROUND(0),
+ BACKGROUND(1)
+}
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:items")
+ useModule(":core:domain:world")
+}
--- /dev/null
+package ru.fredboy.cavedroid.entity.container.abstraction
+
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.entity.container.model.Container
+
+interface ContainerFactory {
+ fun createContainer(type: Block.Container): Container
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.entity.container.abstraction
+
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockDestroyedListener
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockPlacedListener
+import ru.fredboy.cavedroid.entity.container.model.ContainerCoordinates
+import kotlin.reflect.KClass
+
+interface ContainerWorldAdapter {
+
+ fun checkContainerAtCoordinates(
+ coordinates: ContainerCoordinates,
+ requiredType: KClass<out Block.Container>
+ ): Boolean
+
+ fun addOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
+
+ fun addOnBlockPlacedListener(listener: OnBlockPlacedListener)
+
+ fun removeOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
+
+ fun removeOnBlockPlacedListener(listener: OnBlockPlacedListener)
+
+}
\ No newline at end of file
-package ru.fredboy.cavedroid.game.controller.container.model
+package ru.fredboy.cavedroid.entity.container.model
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
class Chest(
- fallbackItem: Item,
+ fallbackItem: Item.None,
initialItems: List<InventoryItem>? = null,
) : Container(
size = SIZE,
initialItems = initialItems
) {
+ override val type get() = Block.Chest::class
+
override fun update(itemByKey: GetItemByKeyUseCase) {
// no-op
}
--- /dev/null
+package ru.fredboy.cavedroid.entity.container.model
+
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.inventory.Inventory
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import kotlin.reflect.KClass
+
+abstract class Container(
+ val size: Int,
+ protected val fallbackItem: Item.None,
+ initialItems: List<InventoryItem>? = null
+) {
+
+ val inventory = Inventory(size, fallbackItem, initialItems)
+
+ val items get() = inventory.items
+
+ abstract val type: KClass<out Block.Container>
+
+ abstract fun update(itemByKey: GetItemByKeyUseCase)
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.entity.container.model
+
+data class ContainerCoordinates(
+ val x: Int,
+ val y: Int,
+ val z: Int,
+) {
+ override fun toString(): String {
+ return "($x;$y;$z)"
+ }
+
+ companion object {
+
+ fun fromString(string: String): ContainerCoordinates {
+ val xyz = string.trim('(', ')').split(';').map(Integer::valueOf)
+ if (xyz.size != 3) {
+ throw IllegalArgumentException("Invalid ContainerCoordinates format")
+ }
+ return ContainerCoordinates(
+ x = xyz[0],
+ y = xyz[1],
+ z = xyz[2],
+ )
+ }
+ }
+}
\ No newline at end of file
-package ru.fredboy.cavedroid.game.controller.container.model
+package ru.fredboy.cavedroid.entity.container.model
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.math.MathUtils
import com.badlogic.gdx.utils.TimeUtils
-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.block.Block
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem.Companion.isNoneOrNull
import ru.fredboy.cavedroid.domain.items.model.item.Item
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
class Furnace(
- fallbackItem: Item,
+ fallbackItem: Item.None,
initialItems: List<InventoryItem>? = null
) : Container(
size = SIZE,
initialItems = initialItems,
) {
+ override val type get() = Block.Furnace::class
+
var fuel: InventoryItem
get() = items[FUEL_INDEX]
set(value) {
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:items")
+ useModule(":core:domain:world")
+}
--- /dev/null
+package ru.fredboy.cavedroid.entity.drop.abstraction
+
+import ru.fredboy.cavedroid.domain.items.model.inventory.Inventory
+
+interface DropAdapter {
+
+ fun dropInventory(x: Float, y: Float, inventory: Inventory)
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.entity.drop.abstraction
+
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockDestroyedListener
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockPlacedListener
+
+interface DropWorldAdapter {
+
+ fun addOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
+
+ fun addOnBlockPlacedListener(listener: OnBlockPlacedListener)
+
+ fun removeOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
+
+ fun removeOnBlockPlacedListener(listener: OnBlockPlacedListener)
+
+}
\ No newline at end of file
-package ru.fredboy.cavedroid.game.controller.drop.model
+package ru.fredboy.cavedroid.entity.drop.model
import com.badlogic.gdx.math.Intersector
+import com.badlogic.gdx.math.MathUtils
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.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
class Drop(
x: Float,
y: Float,
- val item: Item,
- _amount: Int = 1,
+ val inventoryItem: InventoryItem,
) : Rectangle(x, y, DROP_SIZE, DROP_SIZE) {
+ constructor(x: Float, y: Float, item: Item, amount: Int = 1) : this(x, y, InventoryItem(item, amount))
+
val velocity = getInitialVelocity()
var isPickedUp = false
- var amount = _amount
- private set
+
+ val item get() = inventoryItem.item
+
+ val amount get() = inventoryItem.amount
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,
companion object {
- private fun getInitialVelocity(): Vector2 = Vector2(0f, -1f)
+ private fun getInitialVelocity(): Vector2 = Vector2(MathUtils.random(-100f, 100f), -100f)
private const val MAGNET_DISTANCE = 8f
--- /dev/null
+plugins {
+ kotlin
+ ksp
+}
+
+java.sourceCompatibility = ApplicationInfo.sourceCompatibility
+java.targetCompatibility = ApplicationInfo.sourceCompatibility
+
+dependencies {
+ useLibgdx()
+ useDagger()
+
+ useCommonModule()
+ useModule(":core:domain:items")
+ useModule(":core:domain:assets")
+}
--- /dev/null
+package ru.fredboy.cavedroid.entity.mob.abstraction
+
+import ru.fredboy.cavedroid.entity.mob.model.Mob
+
+interface MobBehavior {
+
+ fun update(mob: Mob, worldAdapter: MobWorldAdapter, delta: Float)
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.entity.mob.abstraction
+
+import com.badlogic.gdx.math.Vector2
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+
+interface MobWorldAdapter {
+
+ val height: Int
+
+ val width: Int
+
+ fun setForegroundBlock(x: Int, y: Int, block: Block)
+
+ fun setBackgroundBlock(x: Int, y: Int, block: Block)
+
+ fun getForegroundBlock(x: Int, y: Int): Block
+
+ fun getBackgroundBlock(x: Int, y: Int): Block
+
+ fun destroyForegroundBlock(x: Int, y: Int, shouldDrop: Boolean)
+
+ fun destroyBackgroundBlock(x: Int, y: Int, shouldDrop: Boolean)
+
+ fun findSpawnPoint(): Vector2
+
+}
\ No newline at end of file
-package ru.fredboy.cavedroid.game.controller.mob.model
+package ru.fredboy.cavedroid.entity.mob.model
import com.badlogic.gdx.math.MathUtils
-package ru.fredboy.cavedroid.game.controller.mob.model
+package ru.fredboy.cavedroid.entity.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
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobBehavior
class FallingBlock(
val block: Block,
x: Float,
y: Float,
-) : Mob(x, y, 1.px, 1.px, Direction.RIGHT, Int.MAX_VALUE , {}) {
+ behavior: MobBehavior,
+) : Mob(x, y, 1.px, 1.px, Direction.RIGHT, Int.MAX_VALUE , behavior) {
init {
velocity.y = 1f
-package ru.fredboy.cavedroid.game.controller.mob.model
+package ru.fredboy.cavedroid.entity.mob.model
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.graphics.Color
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.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
-import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobBehavior
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
import kotlin.math.abs
abstract class Mob(
height: Float,
var direction: Direction,
val maxHealth: Int,
- val behaviourStrategy: Mob.(Float) -> Unit,
+ val behavior: MobBehavior,
) : Rectangle(x, y, width, height) {
private var resetTakeDamageTask: ResetTakeDamageTask? = null
)
}
- fun update(delta: Float) {
- this.behaviourStrategy(delta)
+ fun update(mobWorldAdapter: MobWorldAdapter, delta: Float) {
+ behavior.update(this, mobWorldAdapter, delta)
}
open fun getDropItems(
return emptyList()
}
- fun attachToController(mobController: MobController) {
- mobController += this
- }
-
abstract fun draw(spriteBatch: SpriteBatch, x: Float, y: Float, delta: Float)
abstract fun changeDir()
-package ru.fredboy.cavedroid.game.controller.mob.model
+package ru.fredboy.cavedroid.entity.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.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobBehavior
class Pig(
private val sprite: MobSprite.Pig,
x: Float,
- y: Float
-) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, {}) {
+ y: Float,
+ behavior: MobBehavior,
+) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, behavior) {
override val speed get() = SPEED
-package ru.fredboy.cavedroid.game.controller.mob.model
+package ru.fredboy.cavedroid.entity.mob.model
import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.g2d.SpriteBatch
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.inventory.Inventory
+import ru.fredboy.cavedroid.domain.items.model.inventory.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
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobBehavior
class Player(
private val sprite: MobSprite.Player,
private val getFallbackItem: GetFallbackItemUseCase,
x: Float,
y: Float,
-) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, {}) {
+ behavior: MobBehavior,
+) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, behavior) {
+
+ var spawnPoint: Vector2? = null
var inventory = Inventory(
size = INVENTORY_SIZE,
- hotbarSize = HOTBAR_SIZE,
fallbackItem = getFallbackItem(),
)
var headRotation = 0f
+ private var _activeSlot = 0
+
+ var activeSlot
+ get() = _activeSlot
+ set(value) {
+ if (value in 0 ..< HOTBAR_SIZE) {
+ _activeSlot = value
+ }
+ }
+
+ val hotbarItems get() = inventory.items.subList(0, HOTBAR_SIZE)
+
+ val activeItem get() = inventory.items[activeSlot]
+
override val speed get() = SPEED
- override fun changeDir() {
- switchDir()
- velocity = Vector2(direction.basis * speed, 0f)
- }
+ override fun changeDir() = Unit
override fun jump() {
velocity.y = JUMP_VELOCITY
}
override fun draw(spriteBatch: SpriteBatch, x: Float, y: Float, delta: Float) {
+ updateAnimation(delta)
+
with(sprite) {
hand.setFlip(looksRight(), hand.isFlipY)
leg.setFlip(looksRight(), leg.isFlipY)
frontHandAnim = -rightHandAnim
}
- val backgroundTintColor = tintColor.cpy().sub(Color(0xAAAAAA shl 16))
+ val backgroundTintColor = tintColor.cpy().sub(Color(0xAAAAAA shl 8))
hand.color = backgroundTintColor
spriteBatch.drawSprite(hand, x + getBodyRelativeX(), y + getBodyRelativeY(), backHandAnim)
}
}
+ fun respawn(spawnPoint: Vector2) {
+ this.spawnPoint = spawnPoint
+
+ x = spawnPoint.x
+ y = spawnPoint.y
+
+ velocity.setZero()
+ isDead = false
+ heal(maxHealth)
+ }
+
fun startHitting(withDamage: Boolean = true) {
if (isHitting) {
return
isHitting = false
}
- fun decreaseCurrentItemCount() {
+ fun decreaseCurrentItemCount(amount: Int = 1) {
if (gameMode == 1) {
return
}
- inventory.activeItem.subtract()
+ activeItem.subtract(amount)
- if (inventory.activeItem.amount <= 0) {
+ if (activeItem.amount <= 0) {
setCurrentInventorySlotItem(getFallbackItem())
}
}
fun setCurrentInventorySlotItem(item: Item) {
- inventory.items[inventory.activeSlot] = item.toInventoryItem()
+ inventory.items[activeSlot] = item.toInventoryItem()
}
private fun drawItem(spriteBatch: SpriteBatch, x: Float, y: Float, handAnim: Float) {
- val item = inventory.activeItem.item.takeIf { !it.isNone() } ?: return
+ val item = activeItem.item.takeIf { !it.isNone() } ?: return
val itemSprite = item.sprite
val isSmallSprite = !item.isTool() || item.isShears()
val originalWidth = itemSprite.width
const val MAX_HEALTH = 20
- private const val WIDTH = 4f
- private const val HEIGHT = 30f
+ const val WIDTH = 4f
+ const val HEIGHT = 30f
private const val SPEED = 69.072f
private const val JUMP_VELOCITY = -133.332f
useCommonModule()
useModule(":core:domain:items")
+ useModule(":core:domain:world")
+ useModule(":core:entity:container")
+ useModule(":core:entity:drop")
}
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
+import com.badlogic.gdx.Gdx
+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.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockDestroyedListener
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockPlacedListener
+import ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerFactory
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerWorldAdapter
+import ru.fredboy.cavedroid.entity.container.model.Container
+import ru.fredboy.cavedroid.entity.container.model.ContainerCoordinates
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropAdapter
+import javax.inject.Inject
-interface ContainerController {
+@GameScope
+class ContainerController @Inject constructor(
+ private val getItemByKeyUseCase: GetItemByKeyUseCase,
+ private val containerWorldAdapter: ContainerWorldAdapter,
+ private val containerFactory: ContainerFactory,
+ private val dropAdapter: DropAdapter,
+): OnBlockPlacedListener, OnBlockDestroyedListener {
- val size: Int
+ val containerMap = mutableMapOf<ContainerCoordinates, Container>()
- fun getContainer(x: Int, y: Int, z: Int): Container?
+ val size get() = containerMap.size
- fun addContainer(x: Int, y: Int, z: Int, container: Container)
+ init {
+ containerWorldAdapter.addOnBlockPlacedListener(this)
+ containerWorldAdapter.addOnBlockDestroyedListener(this)
+ }
- /**
- * Removes container without notifying listeners
- */
- fun resetContainer(x: Int, y: Int, z: Int)
+ private fun getContainerKey(x: Int, y: Int, z: Int): ContainerCoordinates {
+ return ContainerCoordinates(x, y, z)
+ }
- /**
- * Removes container and notifies listeners
- */
- fun destroyContainer(x: Int, y: Int, z: Int)
+ fun getContainer(x: Int, y: Int, z: Int): Container? {
+ return containerMap[getContainerKey(x, y, z)]
+ }
- fun addContainerAddedListener(listener: ContainerAddedListener)
+ fun addContainer(x: Int, y: Int, z: Int, container: Container) {
+ val key = getContainerKey(x, y, z)
+ if (containerMap.containsKey(key)) {
+ resetContainer(x, y, z)
+ }
- fun removeContainerAddedListener(listener: ContainerAddedListener)
+ containerMap[key] = container
+ }
- fun addContainerRemovedListener(listener: ContainerRemovedListener)
+ private fun retrieveContainer(x: Int, y: Int, z: Int): Container? {
+ return containerMap.remove(getContainerKey(x, y, z))
+ }
- fun removeContainerRemovedListener(listener: ContainerRemovedListener)
+ fun resetContainer(x: Int, y: Int, z: Int) {
+ retrieveContainer(x, y, z)
+ }
- fun update(delta: Float)
+ fun destroyContainer(x: Int, y: Int, z: Int) {
+ retrieveContainer(x, y, z)?.let { container ->
+ dropAdapter.dropInventory(x.px, y.px, container.inventory)
+ }
+ }
- fun dispose()
+ fun update(delta: Float) {
+ val iterator = containerMap.iterator()
+ while (iterator.hasNext()) {
+ val (coordinates, container) = iterator.next()
+ if (!containerWorldAdapter.checkContainerAtCoordinates(coordinates, container.type)) {
+ Gdx.app.log(TAG, "Removing orphaned ${container::class.simpleName} at $coordinates")
+ iterator.remove()
+ } else {
+ container.update(getItemByKeyUseCase)
+ }
+ }
+ }
+
+ fun dispose() {
+ containerMap.clear()
+ containerWorldAdapter.removeOnBlockPlacedListener(this)
+ containerWorldAdapter.removeOnBlockDestroyedListener(this)
+ }
+
+ override fun onBlockDestroyed(block: Block, x: Int, y: Int, layer: Layer, withDrop: Boolean) {
+ destroyContainer(x, y, layer.z)
+ }
+
+ override fun onBlockPlaced(block: Block, x: Int, y: Int, layer: Layer) {
+ if (block is Block.Container) {
+ val container = containerFactory.createContainer(block)
+ addContainer(x, y, layer.z, container)
+ }
+ }
+
+ companion object {
+ private const val TAG = "ContainerControllerImpl"
+ }
}
\ No newline at end of file
import dagger.Binds
import dagger.Module
-import ru.fredboy.cavedroid.game.controller.container.ContainerController
-import ru.fredboy.cavedroid.game.controller.container.impl.ContainerControllerImpl
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerFactory
+import ru.fredboy.cavedroid.game.controller.container.impl.ContainerFactoryImpl
@Module
abstract class ControllerContainerModule {
@Binds
- internal abstract fun bindContainerController(impl: ContainerControllerImpl): ContainerController
+ internal abstract fun bindContainerFactory(impl: ContainerFactoryImpl): ContainerFactory
}
\ 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.impl
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerFactory
+import ru.fredboy.cavedroid.entity.container.model.Chest
+import ru.fredboy.cavedroid.entity.container.model.Container
+import ru.fredboy.cavedroid.entity.container.model.Furnace
+import javax.inject.Inject
+
+@GameScope
+internal class ContainerFactoryImpl @Inject constructor(
+ private val getFallbackItemUseCase: GetFallbackItemUseCase,
+): ContainerFactory {
+
+ override fun createContainer(type: Block.Container): Container {
+ return when (type) {
+ is Block.Furnace -> createFurnace()
+ is Block.Chest -> createChest()
+ }
+ }
+
+ private fun createFurnace(): Furnace {
+ return Furnace(
+ fallbackItem = getFallbackItemUseCase(),
+ )
+ }
+
+ private fun createChest(): Chest {
+ return Chest(
+ fallbackItem = getFallbackItemUseCase(),
+ )
+ }
+
+}
\ 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
-
-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
+++ /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)
- }
-
-}
useCommonModule()
useModule(":core:domain:items")
+ useModule(":core:domain:world")
+ useModule(":core:entity:drop")
}
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.common.di.GameScope
+import ru.fredboy.cavedroid.common.utils.blockCenterPx
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockDestroyedListener
+import ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropWorldAdapter
+import ru.fredboy.cavedroid.entity.drop.model.Drop
+import java.util.*
+import javax.inject.Inject
-interface DropController {
+@GameScope
+class DropController @Inject constructor(
+ private val itemsRepository: ItemsRepository,
+ private val dropWorldAdapter: DropWorldAdapter,
+) : OnBlockDestroyedListener {
- val size: Int
+ private val drops = LinkedList<Drop>()
- fun getAllDrop(): Collection<Drop>
+ constructor(
+ itemsRepository: ItemsRepository,
+ dropWorldAdapter: DropWorldAdapter,
+ initialDrop: Collection<Drop>
+ ) : this(itemsRepository, dropWorldAdapter) {
+ drops.addAll(initialDrop.filterNot { drop -> drop.item.isNone() })
+ }
- fun addDrop(drop: Drop)
+ val size get() = drops.size
- fun addDrop(x: Float, y: Float, item: Item, count: Int)
+ init {
+ dropWorldAdapter.addOnBlockDestroyedListener(this)
+ }
- fun addDrop(x: Float, y: Float, inventoryItem: InventoryItem)
+ fun getAllDrop(): Collection<Drop> {
+ return drops
+ }
- fun forEach(action: (Drop) -> Unit)
+ fun addDrop(drop: Drop) {
+ if (drop.item.isNone()) {
+ return
+ }
- fun update(delta: Float)
+ drops.add(drop)
+ }
- fun addDropAddedListener(listener: DropAddedListener)
+ fun addDrop(x: Float, y: Float, item: Item, count: Int) {
+ addDrop(Drop(x, y, item, count))
+ }
- fun removeDropAddedListener(listener: DropAddedListener)
+ fun addDrop(x: Float, y: Float, inventoryItem: InventoryItem) {
+ addDrop(x, y, inventoryItem.item, inventoryItem.amount)
+ }
- fun addDropRemovedListener(listener: DropRemovedListener)
+ fun forEach(action: (Drop) -> Unit) {
+ drops.forEach(action)
+ }
- fun removeDropRemovedListener(listener: DropRemovedListener)
+ fun update(delta: Float) {
+ val iterator = drops.iterator()
- fun dispose()
+ while (iterator.hasNext()) {
+ val drop = iterator.next();
+ if (drop.isPickedUp) {
+ iterator.remove()
+ }
+ }
+ }
+
+ fun dispose() {
+ drops.clear()
+ }
+
+ override fun onBlockDestroyed(block: Block, x: Int, y: Int, layer: Layer, withDrop: Boolean) {
+ if (!withDrop) {
+ return
+ }
+
+ val dropInfo = block.params.dropInfo ?: return
+ val item = itemsRepository.getItemByKey(dropInfo.itemKey).takeIf { !it.isNone() } ?: return
+
+ addDrop(
+ x = x.blockCenterPx() - Drop.DROP_SIZE / 2,
+ y = y.blockCenterPx() - Drop.DROP_SIZE / 2,
+ item = item,
+ count = dropInfo.count
+ )
+ }
}
\ No newline at end of file
import dagger.Binds
import dagger.Module
-import ru.fredboy.cavedroid.game.controller.drop.DropController
-import ru.fredboy.cavedroid.game.controller.drop.impl.DropControllerImpl
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropAdapter
+import ru.fredboy.cavedroid.game.controller.drop.impl.DropAdapterImpl
@Module
abstract class ControllerDropModule {
@Binds
- internal abstract fun bindDropController(impl: DropControllerImpl): DropController
+ internal abstract fun bindDropAdapter(impl: DropAdapterImpl): DropAdapter
}
\ 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.domain.items.model.inventory.Inventory
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropAdapter
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import javax.inject.Inject
+
+@GameScope
+internal class DropAdapterImpl @Inject constructor(
+ private val dropController: DropController,
+) : DropAdapter {
+
+ override fun dropInventory(x: Float, y: Float, inventory: Inventory) {
+ inventory.items.forEach { item ->
+ dropController.addDrop(x, y, item)
+ }
+ inventory.clear()
+ }
+
+}
\ 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.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
useCommonModule()
useModule(":core:domain:assets")
useModule(":core:domain:items")
+ useModule(":core:domain:world:")
+ useModule(":core:entity:mob")
}
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
+import com.badlogic.gdx.math.MathUtils
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+import ru.fredboy.cavedroid.entity.mob.model.Mob
+import ru.fredboy.cavedroid.entity.mob.model.Player
+import ru.fredboy.cavedroid.game.controller.mob.behavior.PlayerMobBehavior
+import java.util.*
+import javax.inject.Inject
-interface MobController {
+@GameScope
+class MobController @Inject constructor(
+ mobAssetsRepository: MobAssetsRepository,
+ getFallbackItemUseCase: GetFallbackItemUseCase,
+ private val mobWorldAdapter: MobWorldAdapter,
+) {
- val mobs: List<Mob>
+ private val _mobs = LinkedList<Mob>()
- val player: Player
+ val mobs: List<Mob> get() = _mobs
- fun addMob(mob: Mob)
+ var player = Player(
+ sprite = mobAssetsRepository.getPlayerSprites(),
+ getFallbackItem = getFallbackItemUseCase,
+ x = 0f,
+ y = 0f,
+ behavior = PlayerMobBehavior()
+ )
- fun removeMob(mob: Mob)
+ init {
+ respawnPlayer()
+ }
+
+ fun addMob(mob: Mob) {
+ // TODO: Probably shouldn't add if already in the list
+ _mobs.add(mob)
+ }
+
+ fun removeMob(mob: Mob) {
+ _mobs.remove(mob)
+ }
- operator fun plusAssign(mob: Mob) {
- addMob(mob)
+ fun update(delta: Float) {
+ mobs.forEach { mob ->
+ mob.update(mobWorldAdapter, delta)
+ }
+ player.update(mobWorldAdapter, delta)
}
- operator fun minusAssign(mob: Mob) {
- removeMob(mob)
+ fun checkPlayerCursorBounds() {
+ with(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, mobWorldAdapter.height)
+ }
}
+ fun respawnPlayer() {
+ player.respawn(player.spawnPoint ?: mobWorldAdapter.findSpawnPoint())
+ }
+
+ companion object {
+ private const val SURVIVAL_CURSOR_RANGE = 4
+ }
}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.behavior
+
+import ru.fredboy.cavedroid.entity.mob.model.Mob
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobBehavior
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+import kotlin.reflect.KClass
+
+abstract class BaseMobBehavior<MOB : Mob>(
+ val mobType: KClass<MOB>,
+) : MobBehavior {
+
+ final override fun update(mob: Mob, worldAdapter: MobWorldAdapter, delta: Float) {
+ if (mob::class == mobType) {
+ with(mob as MOB) {
+ updateMob(worldAdapter, delta)
+ }
+ } else {
+ throw IllegalArgumentException(
+ "Trying to update mob of type ${mob::class.simpleName} with behavior of ${mobType.simpleName}"
+ )
+ }
+ }
+
+ abstract fun MOB.updateMob(worldAdapter: MobWorldAdapter, delta: Float)
+
+ companion object {
+ private const val TAG = "BaseMobBehavior"
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.behavior
+
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+import ru.fredboy.cavedroid.entity.mob.model.FallingBlock
+
+class FallingBlockMobBehavior : BaseMobBehavior<FallingBlock>(
+ mobType = FallingBlock::class,
+) {
+
+ override fun FallingBlock.updateMob(worldAdapter: MobWorldAdapter, delta: Float) {
+ if (velocity.isZero) {
+ worldAdapter.setForegroundBlock(mapX, middleMapY, block)
+ kill()
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.behavior
+
+import com.badlogic.gdx.math.MathUtils
+import ru.fredboy.cavedroid.entity.mob.model.Pig
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+
+class PigMobBehavior : BaseMobBehavior<Pig>(
+ mobType = Pig::class,
+) {
+
+ override fun Pig.updateMob(worldAdapter: MobWorldAdapter, 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.fredboy.cavedroid.game.controller.mob.behavior
+
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.mob.model.Player
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+
+class PlayerMobBehavior : BaseMobBehavior<Player>(
+ mobType = Player::class,
+) {
+
+ private fun Block?.isHittable() = this != null && !isNone() && params.hitPoints >= 0
+
+ private fun MobWorldAdapter.getTargetBlockWithLayer(x: Int, y: Int): Pair<Block, Layer>? {
+ val foregroundBlock = getForegroundBlock(x, y)
+ val backgroundBlock = getBackgroundBlock(x, y)
+
+ return when {
+ foregroundBlock.isHittable() -> foregroundBlock to Layer.FOREGROUND
+ backgroundBlock.isHittable() -> backgroundBlock to Layer.BACKGROUND
+ else -> null
+ }
+ }
+
+ private fun Player.hitBlock(worldAdapter: MobWorldAdapter) {
+ if (!isHitting || !isHittingWithDamage) {
+ return
+ }
+
+ val (targetBlock, targetLayer) = worldAdapter.getTargetBlockWithLayer(cursorX, cursorY)
+ ?: run {
+ stopHitting()
+ return
+ }
+
+ if (gameMode == 0) {
+ if (blockDamage >= targetBlock.params.hitPoints) {
+ val shouldDrop = activeItem.item.let { itemInHand ->
+ val toolLevel = (itemInHand as? Item.Tool)?.level?.takeIf {
+ targetBlock.params.toolType == itemInHand.javaClass
+ } ?: 0
+
+ toolLevel >= targetBlock.params.toolLevel
+ }
+
+ decreaseCurrentItemCount()
+
+ when (targetLayer) {
+ Layer.FOREGROUND -> worldAdapter.destroyForegroundBlock(cursorX, cursorY, shouldDrop)
+ Layer.BACKGROUND -> worldAdapter.destroyBackgroundBlock(cursorX, cursorY, shouldDrop)
+ }
+ blockDamage = 0f
+ }
+ } else {
+ when (targetLayer) {
+ Layer.FOREGROUND -> worldAdapter.destroyForegroundBlock(cursorX, cursorY, false)
+ Layer.BACKGROUND -> worldAdapter.destroyBackgroundBlock(cursorX, cursorY, false)
+ }
+ stopHitting()
+ }
+ }
+
+ override fun Player.updateMob(worldAdapter: MobWorldAdapter, delta: Float) {
+ hitBlock(worldAdapter)
+
+ if (gameMode == 1) {
+ return
+ }
+
+ val (targetBlock, _) = worldAdapter.getTargetBlockWithLayer(cursorX, cursorY)
+ ?.takeIf { isHitting && isHittingWithDamage }
+ ?: run {
+ blockDamage = 0f
+ return@updateMob
+ }
+
+ var blockDamageMultiplier = 1f
+ (activeItem.item as? Item.Tool)?.let { currentTool ->
+ if (currentTool.javaClass == targetBlock.params.toolType &&
+ currentTool.level >= targetBlock.params.toolLevel) {
+ blockDamageMultiplier = 2f * currentTool.level
+ }
+ blockDamageMultiplier *= currentTool.blockDamageMultiplier
+ }
+
+ if (isHitting && isHittingWithDamage) {
+ blockDamage += 60f * delta * blockDamageMultiplier
+ }
+ }
+}
\ No newline at end of file
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.factory
+
+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.entity.mob.model.FallingBlock
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.behavior.FallingBlockMobBehavior
+import javax.inject.Inject
+
+@GameScope
+class FallingBlockFactory @Inject constructor(
+ private val mobController: MobController,
+) {
+
+ fun create(x: Int, y: Int, block: Block): FallingBlock {
+ val fallingBlock = FallingBlock(
+ block = block,
+ x = x.px,
+ y = y.px,
+ behavior = FallingBlockMobBehavior(),
+ )
+
+ mobController.addMob(fallingBlock)
+
+ return fallingBlock
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.controller.mob.factory
+
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.assets.GameAssetsHolder
+import ru.fredboy.cavedroid.entity.mob.model.Pig
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.controller.mob.behavior.PigMobBehavior
+import javax.inject.Inject
+
+@GameScope
+class PigFactory @Inject constructor(
+ private val mobController: MobController,
+ private val gameAssetsHolder: GameAssetsHolder,
+) {
+
+ fun create(x: Float, y: Float): Pig {
+ val pig = Pig(
+ x = x,
+ y = y,
+ behavior = PigMobBehavior(),
+ sprite = gameAssetsHolder.getPigSprites(),
+ )
+
+ mobController.addMob(pig)
+
+ return pig
+ }
+
+}
\ 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
useCommonModule()
useModule(":core:domain:items")
-
- useModule(":core:game:controller:container")
- useModule(":core:game:controller:drop")
- useModule(":core:game:controller:mob")
+ useModule(":core:domain:world")
+ useModule(":core:entity:container")
+ useModule(":core:entity:drop")
+ useModule(":core:entity:mob")
}
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.common.utils.removeFirst
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.domain.world.listener.OnBlockDestroyedListener
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockPlacedListener
+import ru.fredboy.cavedroid.domain.world.model.Layer
import ru.fredboy.cavedroid.game.world.generator.GameWorldGenerator
import ru.fredboy.cavedroid.game.world.generator.WorldGeneratorConfig
+import java.lang.ref.WeakReference
+import java.util.LinkedList
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 generatorConfig = WorldGeneratorConfig.getDefault()
+ private val onBlockPlacedListeners = LinkedList<WeakReference<OnBlockPlacedListener>>()
+ private val onBlockDestroyedListeners = LinkedList<WeakReference<OnBlockDestroyedListener>>()
+
init {
width = generatorConfig.width
height = generatorConfig.height
- val (generatedFore, generatedBack) = GameWorldGenerator(generatorConfig, itemsRepository).generate()
- foreMap = generatedFore
- backMap = generatedBack
+ if (initialForeMap != null && initialBackMap != null) {
+ foreMap = initialForeMap
+ backMap = initialBackMap
+ } else {
+ val (generatedFore, generatedBack) = GameWorldGenerator(generatorConfig, itemsRepository).generate()
+ foreMap = generatedFore
+ backMap = generatedBack
+ }
+ }
+
+ fun addBlockPlacedListener(listener: OnBlockPlacedListener) {
+ onBlockPlacedListeners.add(WeakReference(listener))
+ }
+
+ fun addBlockDestroyedListener(listener: OnBlockDestroyedListener) {
+ onBlockDestroyedListeners.add(WeakReference(listener))
}
+ fun removeBlockPlacedListener(listener: OnBlockPlacedListener) {
+ onBlockPlacedListeners.removeFirst { it.get() == listener }
+ }
+
+ fun removeBlockDestroyedListener(listener: OnBlockDestroyedListener) {
+ onBlockDestroyedListeners.removeFirst { it.get() == listener }
+ }
+
+
private fun transformX(x: Int): Int {
var transformed = x % width
if (transformed < 0) {
return transformed
}
- private fun getMap(x: Int, y: Int, layer: Int): Block {
+ private fun getMap(x: Int, y: Int, layer: Layer): Block {
val fallback = itemsRepository.fallbackBlock
if (y !in 0 ..< height) {
}
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
- }
+ Layer.FOREGROUND -> foreMap[transformedX][y]
+ Layer.BACKGROUND -> backMap[transformedX][y]
+ }
+ }
+
+ private fun notifyBlockPlaced(x: Int, y: Int, layer: Layer, value: Block) {
+ onBlockPlacedListeners.forEach { listener ->
+ listener.get()?.onBlockPlaced(value, x, y, layer)
}
}
- private fun setMap(x: Int, y: Int, layer: Int, value: Block) {
+ private fun notifyBlockDestroyed(x: Int, y: Int, layer: Layer, value: Block, withDrop: Boolean) {
+ onBlockDestroyedListeners.forEach { listener ->
+ listener.get()?.onBlockDestroyed(value, x, y, layer, withDrop)
+ }
+ }
+
+ private fun setMap(x: Int, y: Int, layer: Layer, value: Block, dropOld: Boolean) {
if (y !in 0 ..< height) {
return
}
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)
+ getMap(x, y, layer)
+ .takeIf { !it.isNone() }
+ ?.let { currentBlock ->
+ notifyBlockDestroyed(x, y, layer, currentBlock, dropOld)
}
- }
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")
- }
+ Layer.FOREGROUND -> foreMap[transformedX][y] = value
+ Layer.BACKGROUND -> backMap[transformedX][y] = value
}
+
+ notifyBlockPlaced(x, y, layer, value)
}
private fun isSameSlab(slab1: Block, slab2: Block): Boolean {
}
fun hasForeAt(x: Int, y: Int): Boolean {
- return !getMap(x, y, FOREGROUND_Z).isNone()
+ return !getMap(x, y, Layer.FOREGROUND).isNone()
}
fun hasBackAt(x: Int, y: Int): Boolean {
- return !getMap(x, y, BACKGROUND_Z).isNone()
+ return !getMap(x, y, Layer.BACKGROUND).isNone()
}
fun getForeMap(x: Int, y: Int): Block {
- return getMap(x, y, FOREGROUND_Z)
+ return getMap(x, y, Layer.FOREGROUND)
}
- fun setForeMap(x: Int, y: Int, block: Block) {
- setMap(x, y, FOREGROUND_Z, block)
+ fun setForeMap(x: Int, y: Int, block: Block, dropOld: Boolean = false) {
+ setMap(x, y, Layer.FOREGROUND, block, dropOld)
}
fun resetForeMap(x: Int, y: Int) {
}
fun getBackMap(x: Int, y: Int): Block {
- return getMap(x, y, BACKGROUND_Z)
+ return getMap(x, y, Layer.BACKGROUND)
}
- fun setBackMap(x: Int, y: Int, block: Block) {
- setMap(x, y, BACKGROUND_Z, block)
+ fun setBackMap(x: Int, y: Int, block: Block, dropOld: Boolean = false) {
+ setMap(x, y, Layer.BACKGROUND, block, dropOld)
}
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)
+ fun placeToForeground(x: Int, y: Int, value: Block, dropOld: Boolean = false): Boolean {
+ val wasPlaced = if (canPlaceToForeground(x, y, value)) {
+ setForeMap(x, y, value, dropOld)
true
} else if (value is Block.Slab && isSameSlab(value, getForeMap(x, y))) {
- setForeMap(x, y, itemsRepository.getBlockByKey(value.otherPartBlockKey))
+ setForeMap(x, y, itemsRepository.getBlockByKey(value.otherPartBlockKey), dropOld)
true
} else {
false
}
+
+ return wasPlaced
}
- fun placeToBackground(x: Int, y: Int, value: Block): Boolean {
- return if (value.isNone() || getBackMap(x, y).isNone() && value.params.hasCollision &&
+ fun placeToBackground(x: Int, y: Int, value: Block, dropOld: Boolean = false): Boolean {
+ val wasPlaced = 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)
+ setBackMap(x, y, value, dropOld)
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)
- }
+ return wasPlaced
}
- fun playerDurateTool() {
- TODO()
+ fun destroyForeMap(x: Int, y: Int, shouldDrop: Boolean) {
+ placeToForeground(x, y, itemsRepository.fallbackBlock, shouldDrop)
}
- private fun shouldDrop(block: Block): Boolean {
- TODO()
+ fun destroyBackMap(x: Int, y: Int, shouldDrop: Boolean) {
+ placeToBackground(x, y, itemsRepository.fallbackBlock, shouldDrop)
}
- 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
--- /dev/null
+package ru.fredboy.cavedroid.game.world.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerWorldAdapter
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropWorldAdapter
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+import ru.fredboy.cavedroid.game.world.impl.WorldAdapterImpl
+
+@Module
+abstract class GameWorldModule {
+
+ @Binds
+ internal abstract fun bindMobWorldAdapter(impl: WorldAdapterImpl): MobWorldAdapter
+
+ @Binds
+ internal abstract fun bindContainerWorldAdapter(impl: WorldAdapterImpl): ContainerWorldAdapter
+
+ @Binds
+ internal abstract fun bindDropWorldAdapter(impl: WorldAdapterImpl): DropWorldAdapter
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.game.world.impl
+
+import com.badlogic.gdx.math.Vector2
+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.world.listener.OnBlockDestroyedListener
+import ru.fredboy.cavedroid.domain.world.listener.OnBlockPlacedListener
+import ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerWorldAdapter
+import ru.fredboy.cavedroid.entity.container.model.ContainerCoordinates
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropWorldAdapter
+import ru.fredboy.cavedroid.entity.mob.model.Player
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+import ru.fredboy.cavedroid.game.world.GameWorld
+import javax.inject.Inject
+import kotlin.reflect.KClass
+
+@GameScope
+internal class WorldAdapterImpl @Inject constructor(
+ private val gameWorld: GameWorld,
+ private val itemsRepository: ItemsRepository,
+) : DropWorldAdapter, ContainerWorldAdapter, MobWorldAdapter {
+
+ override val height: Int
+ get() = gameWorld.height
+
+ override val width: Int
+ get() = gameWorld.width
+
+ override fun setForegroundBlock(x: Int, y: Int, block: Block) {
+ gameWorld.setForeMap(x, y, block)
+ }
+
+ override fun setBackgroundBlock(x: Int, y: Int, block: Block) {
+ gameWorld.setBackMap(x, y, block)
+ }
+
+ override fun getForegroundBlock(x: Int, y: Int): Block {
+ return gameWorld.getForeMap(x, y)
+ }
+
+ override fun getBackgroundBlock(x: Int, y: Int): Block {
+ return gameWorld.getBackMap(x, y)
+ }
+
+ override fun destroyForegroundBlock(x: Int, y: Int, shouldDrop: Boolean) {
+ gameWorld.destroyForeMap(x, y, shouldDrop)
+ }
+
+ override fun destroyBackgroundBlock(x: Int, y: Int, shouldDrop: Boolean) {
+ gameWorld.destroyBackMap(x, y, shouldDrop)
+ }
+
+ override fun findSpawnPoint(): Vector2 {
+ var x = width / 2
+ var y = 0
+
+ while (y++ in 0..gameWorld.generatorConfig.seaLevel) {
+ if (y == gameWorld.generatorConfig.seaLevel) {
+ while (x++ in 0 ..< width) {
+ if (getForegroundBlock(x, y).params.hasCollision) {
+ break
+ } else if (x == width - 1) {
+ setBackgroundBlock(x, y, itemsRepository.getBlockByKey("grass"))
+ break
+ }
+ }
+ break
+ }
+ if (getForegroundBlock(width / 2, y).params.hasCollision) {
+ break
+ }
+ }
+
+ return Vector2(x.px + .5f.px - Player.WIDTH / 2, y.px - Player.HEIGHT)
+ }
+
+ override fun checkContainerAtCoordinates(
+ coordinates: ContainerCoordinates,
+ requiredType: KClass<out Block.Container>
+ ): Boolean {
+ val block = when (coordinates.z) {
+ Layer.FOREGROUND.z -> gameWorld.getForeMap(coordinates.x, coordinates.y)
+ Layer.BACKGROUND.z -> gameWorld.getBackMap(coordinates.x, coordinates.y)
+ else -> itemsRepository.fallbackBlock
+ }
+
+ return block.isContainer() && block::class == requiredType
+ }
+
+ override fun addOnBlockDestroyedListener(listener: OnBlockDestroyedListener) {
+ gameWorld.addBlockDestroyedListener(listener)
+ }
+
+ override fun addOnBlockPlacedListener(listener: OnBlockPlacedListener) {
+ gameWorld.addBlockPlacedListener(listener)
+ }
+
+ override fun removeOnBlockDestroyedListener(listener: OnBlockDestroyedListener) {
+ gameWorld.removeBlockDestroyedListener(listener)
+ }
+
+ override fun removeOnBlockPlacedListener(listener: OnBlockPlacedListener) {
+ gameWorld.removeBlockPlacedListener(listener)
+ }
+}
\ No newline at end of file
import ru.deadsoftware.cavedroid.generated.module.*;
import ru.fredboy.cavedroid.common.di.GameScope;
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository;
+import ru.fredboy.cavedroid.game.controller.container.di.ControllerContainerModule;
+import ru.fredboy.cavedroid.game.controller.drop.di.ControllerDropModule;
+import ru.fredboy.cavedroid.game.world.di.GameWorldModule;
@GameScope
@Component(dependencies = {
RenderModule.class,
KeyboardInputHandlersModule.class,
MouseInputHandlersModule.class,
- UseBlockActionsModule.class
+ UseBlockActionsModule.class,
+ GameWorldModule.class,
+ ControllerContainerModule.class,
+ ControllerDropModule.class,
+
})
public interface GameComponent {
GameProc getGameProc();
import dagger.Provides;
import org.jetbrains.annotations.Nullable;
import ru.deadsoftware.cavedroid.MainConfig;
-import ru.deadsoftware.cavedroid.game.ui.TooltipManager;
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.entity.container.abstraction.ContainerFactory;
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerWorldAdapter;
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropAdapter;
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropWorldAdapter;
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.entity.mob.abstraction.MobWorldAdapter;
import ru.fredboy.cavedroid.game.world.GameWorld;
@Module
@Provides
@GameScope
public static DropController provideDropController(MainConfig mainConfig,
- SaveDataRepository saveDataRepository) {
+ SaveDataRepository saveDataRepository,
+ DropWorldAdapter dropWorldAdapter,
+ ItemsRepository itemsRepository) {
load(mainConfig, saveDataRepository);
- DropController controller = data != null ? data.retrieveDropController() : new DropControllerImpl();
+ DropController controller = data != null
+ ? data.retrieveDropController()
+ : new DropController(itemsRepository, dropWorldAdapter);
makeDataNullIfEmpty();
return controller;
}
@GameScope
public static ContainerController provideFurnaceController(MainConfig mainConfig,
SaveDataRepository saveDataRepository,
- GetItemByKeyUseCase getItemByKeyUseCase
+ GetItemByKeyUseCase getItemByKeyUseCase,
+ ContainerWorldAdapter containerWorldAdapter,
+ ContainerFactory containerFactory,
+ DropAdapter dropAdapter
) {
load(mainConfig, saveDataRepository);
ContainerController controller = data != null
? data.retrieveContainerController()
- : new ContainerControllerImpl(getItemByKeyUseCase);
+ : new ContainerController(getItemByKeyUseCase, containerWorldAdapter, containerFactory, dropAdapter);
makeDataNullIfEmpty();
return controller;
}
public static MobController provideMobsController(MainConfig mainConfig,
SaveDataRepository saveDataRepository,
MobAssetsRepository mobAssetsRepository,
- GetFallbackItemUseCase getFallbackItemUseCase) {
+ GetFallbackItemUseCase getFallbackItemUseCase,
+ MobWorldAdapter mobWorldAdapter
+ ) {
load(mainConfig, saveDataRepository);
MobController controller = data != null
? data.retrieveMobsController()
- : new MobControllerImpl(mobAssetsRepository, getFallbackItemUseCase);
+ : new MobController(mobAssetsRepository, getFallbackItemUseCase, mobWorldAdapter);
makeDataNullIfEmpty();
return controller;
}
@GameScope
public static GameWorld provideGameWorld(MainConfig mainConfig,
SaveDataRepository saveDataRepository,
- ItemsRepository itemsRepository,
- ContainerController containerController,
- MobController mobController,
- DropController dropController
+ ItemsRepository itemsRepository
) {
load(mainConfig, saveDataRepository);
Block[][] fm = data != null ? data.retrieveForeMap() : null;
Block[][] bm = data != null ? data.retrieveBackMap() : null;
makeDataNullIfEmpty();
- return new GameWorld(itemsRepository, containerController, mobController, dropController, fm, bm);
+ return new GameWorld(itemsRepository, fm, bm);
}
}
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
+import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import ru.deadsoftware.cavedroid.MainConfig;
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.model.inventory.InventoryItem;
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase;
+import ru.fredboy.cavedroid.entity.drop.model.Drop;
+import ru.fredboy.cavedroid.entity.mob.model.FallingBlock;
+import ru.fredboy.cavedroid.entity.mob.model.Mob;
+import ru.fredboy.cavedroid.entity.mob.model.Player;
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;
final Player player = mMobController.getPlayer();
if (Intersector.overlaps(shiftedPlayerTarget, drop)) {
- // TODO: Pick up drop
-// player.getInventory().pickDrop(drop);
+ drop.setPickedUp(player.getInventory().pickUpItem(drop.getInventoryItem()));
}
}
mob.x = collidingRect.x + collidingRect.width;
}
-// mob.x = MathUtils.round(mob.getX());
-// while (checkColl(mob) != null) {
-// mob.x += d;
-// }
-
if (mob.getCanJump()) {
mob.changeDir();
}
}
}
- // TODO: Check World Bounds
-// mob.checkWorldBounds(mGameWorld);
+ // Check world bounds
+ final float worldWidthPx = MeasureUnitsUtilsKt.getPx(mGameWorld.getWidth());
+ if (mob.getX() + mob.getWidth() / 2 < 0) {
+ mob.x += worldWidthPx;
+ }
+ if (mob.getX() + mob.getWidth() / 2 > worldWidthPx) {
+ mob.x -= worldWidthPx;
+ }
}
private void mobYColl(Mob mob) {
mob.y = collidingRect.y + collidingRect.height;
}
-
-// mob.y = MathUtils.round(mob.getY());
-//
-// while (checkColl(mob)) {
-// mob.y += d;
-// }
-
mob.getVelocity().y = 0;
} else {
}
}
- private void playerPhy(Player player, float delta) {
+ private void playerPhy(@NotNull Player player, float delta) {
if (player.isDead()) {
return;
}
//todo : Update player
// player.ai(mGameWorld, mGameItemsHolder, mMobController, delta);
if (player.isDead()) {
- for (InventoryItem invItem : player.getInventory().getItems()) {
- mDropController.addDrop(player.x, player.y, invItem);
- }
+// for (InventoryItem invItem : player.getInventory().getItems()) {
+// mDropController.addDrop(player.x, player.y, invItem);
+// }
player.getInventory().clear();
- //todo: Respawn player
-// player.respawn(mGameWorld, mGameItemsHolder);
+ mMobController.respawnPlayer();
}
}
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.entity.mob.model.Player;
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;
}
public void update(float delta) {
+ mMobsController.update(delta);
mGamePhysics.update(delta);
mGameRenderer.render(delta);
mContainerController.update(delta);
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.entity.mob.model.Player;
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;
package ru.deadsoftware.cavedroid.game.actions.placeblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindPlaceBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
package ru.deadsoftware.cavedroid.game.actions.placeblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindPlaceBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
package ru.deadsoftware.cavedroid.game.actions.placeblock
import com.badlogic.gdx.Gdx
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindPlaceBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUpdateBlockAction
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
import ru.fredboy.cavedroid.game.world.GameWorld
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUpdateBlockAction
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
import ru.fredboy.cavedroid.game.world.GameWorld
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUpdateBlockAction
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
import ru.fredboy.cavedroid.game.world.GameWorld
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUpdateBlockAction
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.controller.mob.factory.FallingBlockFactory
import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@BindUpdateBlockAction(stringKey = UpdateRequiresBlockAction.ACTION_KEY)
class UpdateRequiresBlockAction @Inject constructor(
private val gameWorld: GameWorld,
- private val mobController: MobController,
+ private val fallingBlockFactory: FallingBlockFactory,
) : IUpdateBlockAction {
override fun update(x: Int, y: Int) {
if (block.params.isFallable) {
gameWorld.resetForeMap(x, y)
- FallingBlock(block, x.px, y.px)
- .attachToController(mobController)
+ fallingBlockFactory.create(x, y, block)
} else {
- gameWorld.destroyForeMap(x, y)
+ gameWorld.destroyForeMap(x, y, true)
}
}
}
package ru.deadsoftware.cavedroid.game.actions.updateblock
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUpdateBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUpdateBlockAction
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.usecase.GetBlockByKeyUseCase
import ru.fredboy.cavedroid.game.world.GameWorld
package ru.deadsoftware.cavedroid.game.actions.useblock
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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 ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.container.model.Chest
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
import javax.inject.Inject
@GameScope
@BindUseBlockAction(stringKey = UseChestAction.KEY)
class UseChestAction @Inject constructor(
- private val gameWorld: GameWorld,
+ private val containerController: ContainerController,
private val gameWindowsManager: GameWindowsManager,
) : IUseBlockAction {
override fun perform(block: Block, x: Int, y: Int) {
- val chest = (gameWorld.getForegroundContainer(x, y) as? Chest)
- ?: (gameWorld.getBackgroundContainer(x, y) as? Chest)
+ // TODO: transform x
+ val chest = (containerController.getContainer(x, y, Layer.FOREGROUND.z) as? Chest)
+ ?: (containerController.getContainer(x, y, Layer.BACKGROUND.z) as? Chest)
?: return
gameWindowsManager.openChest(chest)
}
package ru.deadsoftware.cavedroid.game.actions.useblock
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUseBlockAction
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.model.block.Block
import javax.inject.Inject
package ru.deadsoftware.cavedroid.game.actions.useblock
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseBlockAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUseBlockAction
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.container.model.Furnace
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
@GameScope
@BindUseBlockAction(stringKey = UseFurnaceAction.KEY)
class UseFurnaceAction @Inject constructor(
- private val gameWorld: GameWorld,
+ private val containerController: ContainerController,
private val gameWindowsManager: GameWindowsManager,
) : IUseBlockAction {
override fun perform(block: Block, x: Int, y: Int) {
- val furnace = gameWorld.getForegroundFurnace(x, y) ?: gameWorld.getBackgroundFurnace(x, y) ?: return
+ // TODO: transform x
+ val furnace = (containerController.getContainer(x, y, Layer.FOREGROUND.z)
+ ?: containerController.getContainer(x, y, Layer.FOREGROUND.z)) as? Furnace
+ furnace ?: return
+
gameWindowsManager.openFurnace(furnace)
}
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
if (gameWorld.canPlaceToForeground(x, y, bedLeft) && gameWorld.canPlaceToForeground(x + 1, y, bedRight)) {
gameWorld.placeToForeground(x, y, bedLeft)
gameWorld.placeToForeground(x + 1, y, bedRight)
- mobController.player.inventory.decreaseCurrentItemAmount()
+ mobController.player.decreaseCurrentItemCount()
}
}
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindUseItemAction
import ru.fredboy.cavedroid.common.di.GameScope
-import ru.fredboy.cavedroid.domain.assets.usecase.GetPigSpritesUseCase
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 ru.fredboy.cavedroid.game.controller.mob.factory.PigFactory
import javax.inject.Inject
@GameScope
@BindUseItemAction(UsePigSpawnEggAction.ACTION_KEY)
class UsePigSpawnEggAction @Inject constructor(
private val mobController: MobController,
- private val getPigSprites: GetPigSpritesUseCase,
+ private val pigFactory: PigFactory,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
- Pig(getPigSprites(), mobController.player.cursorX.px, mobController.player.cursorY.px)
- .apply { attachToController(mobController) }
-
+ pigFactory.create(mobController.player.cursorX.px, mobController.player.cursorY.px)
mobController.player.decreaseCurrentItemCount()
}
package ru.deadsoftware.cavedroid.game.actions.useitem
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindUseItemAction
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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
"Drops: ${dropController.size}",
"Containers: ${containerController.size}",
"Block: ${gameWorld.getForeMap(player.cursorX, player.cursorY).params.key}",
- "Hand: ${player.inventory.activeItem.item.params.key}",
+ "Hand: ${player.activeItem.item.params.key}",
"Game mode: ${player.gameMode}",
"Block damage: ${player.blockDamage}"
)
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.deadsoftware.cavedroid.misc.annotations.multibind.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 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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.items.model.item.Item
+import ru.fredboy.cavedroid.entity.drop.model.Drop
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
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.DropItem &&
action.isKeyDown && gameWindowsManager.getCurrentWindow() == GameUiWindow.NONE &&
- !mobController.player.inventory.activeItem.item.isNone()
+ !mobController.player.activeItem.item.isNone()
}
private fun createDrop(item: Item, playerX: Float, playerY: Float, amount: Int) {
override fun handle(action: KeyboardInputAction) {
val player = mobController.player
- val currentItem = player.inventory.activeItem
+ val currentItem = player.activeItem
val dropAmount = if (currentItem.item.isTool()) currentItem.amount else 1
createDrop(currentItem.item, player.x, player.y, dropAmount)
- player.inventory.decreaseCurrentItemAmount(dropAmount)
+ player.decreaseCurrentItemCount(dropAmount)
}
companion object {
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Direction
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Direction
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
class MoveCursorControlsModeKeyboardInputHandler @Inject constructor(
private val mainConfig: MainConfig,
private val mobsController: MobController,
- private val gameWorld: GameWorld,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
else -> return
}
- gameWorld.checkPlayerCursorBounds()
+ mobsController.checkPlayerCursorBounds()
}
}
\ No newline at end of file
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
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.deadsoftware.cavedroid.misc.annotations.multibind.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.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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
}
override fun handle(action: KeyboardInputAction) {
- mobController.player.inventory.activeSlot = (action.actionKey as KeyboardInputActionKey.SelectHotbarSlot).slot
+ mobController.player.activeSlot = (action.actionKey as KeyboardInputActionKey.SelectHotbarSlot).slot
}
}
\ No newline at end of file
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
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 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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
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.deadsoftware.cavedroid.misc.annotations.multibind.BindKeyboardInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@GameScope
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.model.inventory.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem.Companion.isNoneOrNull
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
abstract class AbstractInventoryItemsMouseInputHandler(
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.input.isInsideHotbar
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.game.controller.mob.MobController
mobController.player.stopHitting()
} else {
mobController.player.startHitting()
- };
+ }
}
}
\ 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.misc.annotations.multibind.BindMouseInputHandler
import com.badlogic.gdx.graphics.g2d.TextureRegion
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
import com.badlogic.gdx.math.MathUtils
import ru.deadsoftware.cavedroid.MainConfig
import ru.deadsoftware.cavedroid.game.GameUiWindow
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.misc.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
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.entity.mob.model.Direction
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
!mainConfig.isTouch -> handleMouse(action)
}
- gameWorld.checkPlayerCursorBounds()
+ mobController.checkPlayerCursorBounds()
if (player.controlMode == Player.ControlMode.WALK && mainConfig.isTouch) {
setPlayerDirectionToCursor()
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.utils.Timer
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.handler.keyboard.DropItemKeyboardInputHandler.Companion.DROP_DISTANCE
import ru.deadsoftware.cavedroid.game.input.isInsideHotbar
+import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
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.entity.drop.model.Drop
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
}
private fun handleUp(action: MouseInputAction) {
- mobController.player.inventory.activeSlot = getActionSlot(action)
+ mobController.player.activeSlot = getActionSlot(action)
}
private fun handleScroll(action: MouseInputAction) {
if (action.actionKey !is MouseInputActionKey.Scroll) {
return
}
- 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
+ mobController.player.activeSlot += action.actionKey.amountY.toInt()
+ if (mobController.player.activeSlot < 0) {
+ mobController.player.activeSlot = Player.HOTBAR_SIZE - 1
+ } else if (mobController.player.activeSlot >= Player.HOTBAR_SIZE) {
+ mobController.player.activeSlot = 0
}
}
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.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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.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.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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.deadsoftware.cavedroid.game.input.isInsideWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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.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.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.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.model.inventory.InventoryItem.Companion.isNoneOrNull
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
-import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import ru.fredboy.cavedroid.entity.container.model.Furnace
import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
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.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
package ru.deadsoftware.cavedroid.game.input.handler.mouse
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.utils.Timer
import ru.deadsoftware.cavedroid.game.GameUiWindow
cancelHold()
val player = mobController.player
- val item = player.inventory.activeItem.item
+ val item = player.activeItem.item
player.startHitting(false)
player.stopHitting()
private fun handleUp(action: MouseInputAction) {
val player = mobController.player
- val item = player.inventory.activeItem.item
+ val item = player.activeItem.item
cancelHold()
player.startHitting(false)
package ru.deadsoftware.cavedroid.game.input.handler.touch
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindMouseInputHandler
import com.badlogic.gdx.utils.TimeUtils
import ru.deadsoftware.cavedroid.MainConfig
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction
import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindMouseInputHandler
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
+import ru.fredboy.cavedroid.entity.mob.model.Direction
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
cursorTimeoutMs = TimeUtils.millis()
}
- gameWorld.checkPlayerCursorBounds()
+ mobController.checkPlayerCursorBounds()
if (mobController.player.cursorX != pastCursorX || mobController.player.cursorY != pastCursorY) {
mobController.player.blockDamage = 0f
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
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.container.ContainerController
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
class BackgroundBlocksRenderer @Inject constructor(
gameWorld: GameWorld,
mobController: MobController,
+ containerController: ContainerController,
getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
getBlockDamageSprite: GetBlockDamageSpriteUseCase
-) : BlocksRenderer(gameWorld, mobController, getBlockDamageFrameCount, getBlockDamageSprite) {
+) : BlocksRenderer(gameWorld, mobController, containerController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageSpriteUseCase
import ru.fredboy.cavedroid.common.utils.px
import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.world.model.Layer
+import ru.fredboy.cavedroid.entity.container.model.Furnace
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
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: MobController,
+ protected val containerController: ContainerController,
protected val getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
protected val getBlockDamageSprite: GetBlockDamageSpriteUseCase,
) : IGameRenderer {
val drawX = x.px - viewport.x
val drawY = y.px - viewport.y
if (backgroundBlock is Block.Furnace) {
- backgroundBlock.draw(spriteBatch, drawX, drawY, gameWorld.getBackgroundFurnace(x, y)?.isActive ?: false)
+ val furnace = containerController.getContainer(x, y, Layer.BACKGROUND.z) as? Furnace
+ backgroundBlock.draw(spriteBatch, drawX, drawY, furnace?.isActive ?: false)
} else {
backgroundBlock.draw(spriteBatch, drawX, drawY)
}
val drawY = y.px - viewport.y
if (foregroundBlock is Block.Furnace) {
- foregroundBlock.draw(spriteBatch, drawX, drawY, gameWorld.getForegroundFurnace(x, y)?.isActive ?: false)
+ val furnace = containerController.getContainer(x, y, Layer.FOREGROUND.z) as? Furnace
+ foregroundBlock.draw(spriteBatch, drawX, drawY, furnace?.isActive ?: false)
} else {
foregroundBlock.draw(spriteBatch, drawX, drawY)
}
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.MainConfig
import ru.deadsoftware.cavedroid.game.debug.DebugInfoStringsProvider
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.common.utils.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.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.common.utils.cycledInsideWorld
import ru.fredboy.cavedroid.common.utils.drawSprite
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
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.container.ContainerController
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
class ForegroundBlocksRenderer @Inject constructor(
gameWorld: GameWorld,
mobController: MobController,
+ containerController: ContainerController,
getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
getBlockDamageSprite: GetBlockDamageSpriteUseCase
-) : BlocksRenderer(gameWorld, mobController, getBlockDamageFrameCount, getBlockDamageSprite) {
+) : BlocksRenderer(gameWorld, mobController, containerController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
import ru.deadsoftware.cavedroid.game.ui.TooltipManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.common.utils.drawString
+import ru.fredboy.cavedroid.common.utils.px
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
-import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.entity.mob.model.Player
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
spriteBatch.draw(
/* region = */ hotbarSelectorTexture,
/* x = */ hotbarX - HotbarSelectorConfig.horizontalPadding
- + mobController.player.inventory.activeSlot * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
+ + mobController.player.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.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
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.entity.mob.model.Mob
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
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.input.Joystick
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsManager
-import ru.deadsoftware.cavedroid.misc.annotations.multibinding.BindRenderer
+import ru.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
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.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
-import ru.fredboy.cavedroid.game.controller.mob.model.Player
import javax.inject.Inject
@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.deadsoftware.cavedroid.misc.annotations.multibind.BindRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import javax.inject.Inject
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.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.model.item.Item
abstract class AbstractWindowRenderer {
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
class CraftingWindowRenderer @Inject constructor(
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
- private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
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.entity.mob.model.Direction
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
private val mainConfig: MainConfig,
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
- private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
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.entity.container.model.Chest
+import ru.fredboy.cavedroid.entity.container.model.Furnace
import ru.fredboy.cavedroid.game.controller.drop.DropController
import ru.fredboy.cavedroid.game.controller.mob.MobController
import javax.inject.Inject
import com.badlogic.gdx.math.MathUtils
import ru.deadsoftware.cavedroid.game.GameUiWindow
-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.inventory.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem.Companion.isNoneOrNull
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
abstract class AbstractInventoryWindow {
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
abstract class AbstractInventoryWindowWithCraftGrid(
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
-import ru.fredboy.cavedroid.game.controller.container.model.Chest
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
+import ru.fredboy.cavedroid.entity.container.model.Chest
class ChestInventoryWindow(val chest: Chest) : AbstractInventoryWindow() {
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
class CraftingInventoryWindow(
import ru.deadsoftware.cavedroid.game.GameUiWindow
import ru.deadsoftware.cavedroid.game.ui.windows.GameWindowsConfigs
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
class CreativeInventoryWindow() : AbstractInventoryWindow() {
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
-import ru.fredboy.cavedroid.game.controller.container.model.Furnace
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
+import ru.fredboy.cavedroid.entity.container.model.Furnace
class FurnaceInventoryWindow(
val furnace: Furnace,
package ru.deadsoftware.cavedroid.game.ui.windows.inventory
import ru.deadsoftware.cavedroid.game.GameUiWindow
-import ru.fredboy.cavedroid.domain.items.model.item.InventoryItem
+import ru.fredboy.cavedroid.domain.items.model.inventory.InventoryItem
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
class SurvivalInventoryWindow(
import com.badlogic.gdx.utils.Timer
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
class GameWorldMobDamageControllerTask @Inject constructor(
private val mobController: MobController,
private val gameWorld: GameWorld,
- private val itemsRepository: ItemsRepository,
) : Timer.Task() {
override fun run() {
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
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
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
import ru.deadsoftware.cavedroid.game.input.IMouseInputHandler
import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
import ru.deadsoftware.cavedroid.game.actions.placeblock.IPlaceBlockAction
import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
import ru.deadsoftware.cavedroid.game.render.IGameRenderer
import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
import ru.deadsoftware.cavedroid.game.actions.updateblock.IUpdateBlockAction
import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
import ru.deadsoftware.cavedroid.game.actions.useblock.IUseBlockAction
import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
-package ru.deadsoftware.cavedroid.misc.annotations.multibinding
+package ru.deadsoftware.cavedroid.misc.annotations.multibind
import ru.deadsoftware.cavedroid.game.actions.useitem.IUseItemAction
import ru.deadsoftware.cavedroid.misc.annotations.multibind.MultibindingConfig
*/
include("core:common")
-// data modules
+/**
+ * Data modules
+ */
include("core:data:assets")
include("core:data:items")
include("core:data:save")
-// domain modules
+/**
+ * First level domain models
+ */
include("core:domain:assets")
include("core:domain:items")
+include("core:domain:world")
include("core:domain:save")
+/**
+ * Second level domain models
+ */
+include("core:entity:container")
+include("core:entity:drop")
+include("core:entity:mob")
+
/**
* Game scope modules
*/
