--- /dev/null
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{kt,kts}]
+ktlint_code_style=intellij_idea
+ktlint_standard_multiline-expression-wrapping = disabled
+ktlint_standard_string-template-indent = disabled
+ktlint_standard_comment-wrapping = disabled
+ktlint_standard_no-empty-first-line-in-class-body = disabled
+ktlint_standard_property-naming = disabled
+
+[**/generated/**]
+generated_code = true
+ij_formatter_enabled = false
+ktlint = disabled
null
}
-
android {
namespace = ApplicationInfo.packageName
compileSdk = 34
named("debug") {
res.srcDir("src/debug/res")
}
-
}
compileOptions {
natives(Dependencies.LibGDX.Android.Natives.x86_64)
configurations["implementation"].exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk8")
-}
\ No newline at end of file
+}
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
- android:theme="@style/GdxTheme" tools:ignore="GoogleAppIndexingWarning"
- android:fullBackupContent="@xml/backup_descriptor">
+ android:theme="@style/GdxTheme" tools:ignore="GoogleAppIndexingWarning">
<activity
android:exported="true"
android:name="ru.deadsoftware.cavedroid.AndroidLauncher"
- android:label="@string/app_name"
android:screenOrientation="sensorLandscape"
android:configChanges="keyboard|keyboardHidden|navigation|orientation|screenSize"
tools:ignore="LockedOrientationActivity">
super.onCreate(savedInstanceState)
val gameDataDirectoryPath = packageManager.getPackageInfo(packageName, 0)
- .applicationInfo.dataDir;
+ .applicationInfo.dataDir
val config = AndroidApplicationConfiguration()
config.useImmersiveMode = true
gameDataDirectoryPath = gameDataDirectoryPath,
isTouchScreen = true,
isDebug = BuildConfig.DEBUG,
- preferencesStore = AndroidPreferencesStore(applicationContext)
+ preferencesStore = AndroidPreferencesStore(applicationContext),
),
- /* config = */ config
+ /* config = */ config,
)
}
override fun onBackPressed() {
// ignore
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.api.PreferencesStore
class AndroidPreferencesStore(
- private val context: Context
+ private val context: Context,
) : PreferencesStore {
private val sharedPreferences by lazy { context.getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE) }
private companion object {
private const val SHARED_PREFS_NAME = "cavedroid_prefs"
}
-}
\ No newline at end of file
+}
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
<background android:drawable="@drawable/ic_launcher_background" />
<foreground android:drawable="@drawable/ic_launcher_foreground" />
+ <monochrome/>
</adaptive-icon>
+plugins {
+ ktlintGradle
+}
+
buildscript {
repositories {
mavenLocal()
maven { url = uri("https://jitpack.io") }
maven { url = uri("https://mvn.fredboy.ru/releases/") }
}
-}
\ No newline at end of file
+}
const val ksp = "ru.fredboy:automultibind-ksp:${Versions.automultibind}"
}
- object KtLint {
- const val ktlintGradlePlugin = "org.jlleitschuh.gradle:ktlint:${Versions.ktlintGradle}"
- }
-
const val androidGradlePlugin = "com.android.tools.build:gradle:${Versions.agp}"
}
\ No newline at end of file
object CaveDroidConstants {
const val VERSION = "alpha 0.9.2"
-
-}
\ No newline at end of file
+}
fun loadGame()
fun exitGame()
-
-}
\ No newline at end of file
+}
fun getPreference(key: String): String?
fun setPreference(key: String, value: String?)
-
-}
\ No newline at end of file
+}
data object MultibindingConfig {
const val GENERATED_MODULES_PACKAGE = "ru.deadsoftware.cavedroid.generated.module"
-}
\ No newline at end of file
+}
package ru.fredboy.cavedroid.common.base
-interface MainConfiguration {
-}
\ No newline at end of file
+interface MainConfiguration
}
return Vector2(
stickVector.x * value,
- stickVector.y * value
+ stickVector.y * value,
)
}
const val SIZE = RADIUS * 2
const val STICK_SIZE = 32f
}
-
-}
\ No newline at end of file
+}
fun applyToSprite(sprite: Sprite) {
sprite.setOrigin(sprite.width * x, sprite.height * y)
}
-
}
fun <T> MutableCollection<T>.removeFirst(predicate: (T) -> Boolean): Boolean {
return retrieveFirst(predicate) != null
-}
\ No newline at end of file
+}
private fun Rectangle.shifted(shift: Float) = Rectangle(x + shift, y, width, height)
-private fun Rectangle.getLazyShifts(worldWidthPx: Float)
- = Triple(
- first = lazy { shifted(0f) },
- second = lazy { shifted(-worldWidthPx) },
- third = lazy { shifted(worldWidthPx) }
- )
+private fun Rectangle.getLazyShifts(worldWidthPx: Float) = Triple(
+ first = lazy { shifted(0f) },
+ second = lazy { shifted(-worldWidthPx) },
+ third = lazy { shifted(worldWidthPx) },
+)
fun Rectangle.cycledInsideWorld(
viewport: Rectangle,
str: String,
x: Float,
y: Float,
- color: Color = Color.WHITE
+ color: Color = Color.WHITE,
): GlyphLayout {
font.color = color
return font.draw(this, str, x, y)
y: Float,
width: Float,
height: Float,
- block: () -> Unit
+ block: () -> Unit,
) {
val scaleX = Gdx.graphics.width / viewportWidth
val scaleY = Gdx.graphics.height / viewportHeight
/* x = */ (x * scaleX).toInt(),
/* y = */ ((viewportHeight - y - height) * scaleY).toInt(),
/* width = */ (width * scaleX).toInt(),
- /* height = */ (height * scaleY).toInt()
+ /* height = */ (height * scaleY).toInt(),
)
block.invoke()
flush()
import dagger.Binds
import dagger.Module
-import ru.fredboy.cavedroid.data.assets.internal.*
+import ru.fredboy.cavedroid.data.assets.internal.BlockAssetsRepositoryImpl
import ru.fredboy.cavedroid.data.assets.internal.BlockDamageAssetsRepositoryImpl
import ru.fredboy.cavedroid.data.assets.internal.FontAssetsRepositoryImpl
+import ru.fredboy.cavedroid.data.assets.internal.ItemsAssetsRepositoryImpl
import ru.fredboy.cavedroid.data.assets.internal.MobAssetsRepositoryImpl
import ru.fredboy.cavedroid.data.assets.internal.TextureRegionsAssetsRepositoryImpl
-import ru.fredboy.cavedroid.domain.assets.repository.*
+import ru.fredboy.cavedroid.data.assets.internal.TouchButtonsRepositoryImpl
+import ru.fredboy.cavedroid.domain.assets.repository.BlockAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.BlockDamageAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.FontAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.ItemsAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.TextureRegionsAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.TouchButtonsAssetsRepository
@Module
abstract class DataAssetsModule {
@Binds
internal abstract fun bindBlockDamageAssetsRepository(
- impl: BlockDamageAssetsRepositoryImpl
+ impl: BlockDamageAssetsRepositoryImpl,
): BlockDamageAssetsRepository
@Binds
internal abstract fun bindMobAssetsRepository(
- impl: MobAssetsRepositoryImpl
+ impl: MobAssetsRepositoryImpl,
): MobAssetsRepository
@Binds
internal abstract fun bindTextureRegionsAssetsRepository(
- impl: TextureRegionsAssetsRepositoryImpl
+ impl: TextureRegionsAssetsRepositoryImpl,
): TextureRegionsAssetsRepository
@Binds
internal abstract fun bindFontAssetsRepository(
- impl: FontAssetsRepositoryImpl
+ impl: FontAssetsRepositoryImpl,
): FontAssetsRepository
@Binds
internal abstract fun bindBlockAssetsRepository(
- impl: BlockAssetsRepositoryImpl
+ impl: BlockAssetsRepositoryImpl,
): BlockAssetsRepository
@Binds
internal abstract fun bindItemsAssetsRepository(
- impl: ItemsAssetsRepositoryImpl
+ impl: ItemsAssetsRepositoryImpl,
): ItemsAssetsRepository
@Binds
internal abstract fun bindTouchButtonsAssetsRepository(
- impl: TouchButtonsRepositoryImpl
+ impl: TouchButtonsRepositoryImpl,
): TouchButtonsAssetsRepository
-
-}
\ No newline at end of file
+}
companion object {
private const val BLOCKS_TEXTURES_PATH = "textures/textures/blocks"
}
-
-}
\ No newline at end of file
+}
package ru.fredboy.cavedroid.data.assets.internal
import com.badlogic.gdx.graphics.g2d.Sprite
-import ru.fredboy.cavedroid.domain.assets.repository.BlockDamageAssetsRepository
import ru.fredboy.cavedroid.common.utils.BLOCK_SIZE_PX
import ru.fredboy.cavedroid.common.utils.bl
import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.assets.repository.BlockDamageAssetsRepository
import javax.inject.Inject
import javax.inject.Singleton
x = index.px.toInt(),
y = 0,
width = blockSize,
- height = blockSize
+ height = blockSize,
)
}
}
companion object {
private const val BLOCK_DAMAGE_SHEET_PATH = "textures/break.png"
}
-
-}
\ No newline at end of file
+}
private const val FONT_FILE_PATH = "font.fnt"
private const val FONT_SCALE = .375f
}
-}
\ No newline at end of file
+}
companion object {
private const val ITEMS_TEXTURES_PATH = "textures/textures/items"
}
-
-}
\ No newline at end of file
+}
import javax.inject.Singleton
@Singleton
-internal class MobAssetsRepositoryImpl @Inject constructor(): MobAssetsRepository() {
+internal class MobAssetsRepositoryImpl @Inject constructor() : MobAssetsRepository() {
private var playerSprite: MobSprite.Player? = null
private const val PLAYER_SPRITES_PATH = "textures/mobs/char"
private const val PIG_SPRITES_PATH = "textures/mobs/pig"
}
-
-}
\ No newline at end of file
+}
x = 0,
y = 0,
width = texture.width,
- height = texture.height
+ height = texture.height,
)
} else {
fileData.forEach { (regionName, regionData) ->
x = regionData.x,
y = regionData.y,
width = regionData.width ?: texture.width,
- height = regionData.height ?: texture.height
+ height = regionData.height ?: texture.height,
)
}
}
private const val JSON_TEXTURE_REGIONS = "json/texture_regions.json"
}
-
}
private const val JSON_TOUCH_BUTTONS = "json/touch_buttons.json"
}
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindApplicationContextRepository(impl: ApplicationContextRepositoryImpl): ApplicationContextRepository
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindGameContextRepository(impl: GameContextRepositoryImpl): GameContextRepository
-}
\ No newline at end of file
+}
internal var showInfo: Boolean,
internal var showMap: Boolean,
internal var joystick: Joystick,
- internal var cameraContext: CameraContext
+ internal var cameraContext: CameraContext,
)
package ru.fredboy.cavedroid.data.configuration.repository
-import com.badlogic.gdx.Application
import com.badlogic.gdx.Gdx
import ru.fredboy.cavedroid.data.configuration.store.ApplicationContextStore
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
}
if (fullscreen) {
- Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode);
+ Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode)
} else {
Gdx.graphics.setWindowedMode(960, 540)
setWidth(Gdx.graphics.width.toFloat() / 2)
override fun setHeight(height: Float) {
applicationContextStore.height = height
}
-}
\ No newline at end of file
+}
@GameScope
class GameContextRepositoryImpl @Inject constructor(
- private val gameContextStore: GameContextStore
+ private val gameContextStore: GameContextStore,
) : GameContextRepository {
override fun isLoadGame(): Boolean = gameContextStore.isLoadGame
get() = synchronized(lock) { applicationContext.height }
set(value) = synchronized(lock) { applicationContext.height = value }
-
private companion object {
private const val KEY_FULLSCREEN_PREF = "fullscreen"
private const val KEY_DYNAMIC_CAMERA_PREF = "dyncam"
}
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.common.model.Joystick
-import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
import ru.fredboy.cavedroid.data.configuration.model.GameContext
+import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
import javax.inject.Inject
@GameScope
class GameContextStore @Inject constructor(
- private val gameContext: GameContext
+ private val gameContext: GameContext,
) {
private val lock = Any()
@Binds
internal abstract fun bindItemsRepository(impl: ItemsRepositoryImpl): ItemsRepository
-
}
import ru.fredboy.cavedroid.data.items.model.BlockDto
import ru.fredboy.cavedroid.data.items.repository.ItemsRepositoryImpl
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockTextureUseCase
-import ru.fredboy.cavedroid.domain.items.model.block.*
-import ru.fredboy.cavedroid.domain.items.model.block.Block.*
+import ru.fredboy.cavedroid.domain.items.model.block.Block
+import ru.fredboy.cavedroid.domain.items.model.block.Block.Chest
+import ru.fredboy.cavedroid.domain.items.model.block.Block.Furnace
+import ru.fredboy.cavedroid.domain.items.model.block.Block.Lava
+import ru.fredboy.cavedroid.domain.items.model.block.Block.None
+import ru.fredboy.cavedroid.domain.items.model.block.Block.Normal
+import ru.fredboy.cavedroid.domain.items.model.block.Block.Slab
+import ru.fredboy.cavedroid.domain.items.model.block.Block.Water
+import ru.fredboy.cavedroid.domain.items.model.block.BlockAnimationInfo
+import ru.fredboy.cavedroid.domain.items.model.block.BlockDropInfo
+import ru.fredboy.cavedroid.domain.items.model.block.BlockMargins
+import ru.fredboy.cavedroid.domain.items.model.block.CommonBlockParams
import ru.fredboy.cavedroid.domain.items.model.item.Item
import javax.inject.Inject
import javax.inject.Singleton
left = dto.left,
top = dto.top,
right = dto.right,
- bottom = dto.bottom
+ bottom = dto.bottom,
),
hitPoints = dto.hp,
dropInfo = mapBlockDropInfo(dto),
}
private fun mapToolType(dto: BlockDto): Class<out Item.Tool>? {
- return when(dto.toolType) {
+ return when (dto.toolType) {
"shovel" -> Item.Shovel::class.java
"sword" -> Item.Sword::class.java
"pickaxe" -> Item.Pickaxe::class.java
return getBlockTexture[textureName]
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.domain.items.model.block.Block
import ru.fredboy.cavedroid.domain.items.model.item.CommonItemParams
import ru.fredboy.cavedroid.domain.items.model.item.Item
-import ru.fredboy.cavedroid.domain.items.model.item.Item.*
import javax.inject.Inject
import javax.inject.Singleton
val params = mapCommonParams(key, dto)
return when (dto.type) {
- "normal" -> Normal(
+ "normal" -> Item.Normal(
params = params,
- sprite = requireNotNull(loadSprite(dto))
+ sprite = requireNotNull(loadSprite(dto)),
)
- "usable" -> Usable(
+ "usable" -> Item.Usable(
params = params,
sprite = requireNotNull(loadSprite(dto)),
- useActionKey = requireNotNull(dto.actionKey)
+ useActionKey = requireNotNull(dto.actionKey),
)
- "shovel" -> Shovel(
+ "shovel" -> Item.Shovel(
params = params,
sprite = requireNotNull(loadSprite(dto)),
mobDamageMultiplier = dto.mobDamageMultiplier,
blockDamageMultiplier = dto.blockDamageMultiplier,
- level = requireNotNull(dto.toolLevel)
+ level = requireNotNull(dto.toolLevel),
)
- "sword" -> Sword(
+ "sword" -> Item.Sword(
params = params,
sprite = requireNotNull(loadSprite(dto)),
mobDamageMultiplier = dto.mobDamageMultiplier,
blockDamageMultiplier = dto.blockDamageMultiplier,
- level = requireNotNull(dto.toolLevel)
+ level = requireNotNull(dto.toolLevel),
)
- "pickaxe" -> Pickaxe(
+ "pickaxe" -> Item.Pickaxe(
params = params,
sprite = requireNotNull(loadSprite(dto)),
mobDamageMultiplier = dto.mobDamageMultiplier,
blockDamageMultiplier = dto.blockDamageMultiplier,
- level = requireNotNull(dto.toolLevel)
+ level = requireNotNull(dto.toolLevel),
)
- "axe" -> Axe(
+ "axe" -> Item.Axe(
params = params,
sprite = requireNotNull(loadSprite(dto)),
mobDamageMultiplier = dto.mobDamageMultiplier,
blockDamageMultiplier = dto.blockDamageMultiplier,
- level = requireNotNull(dto.toolLevel)
+ level = requireNotNull(dto.toolLevel),
)
- "shears" -> Shears(
+ "shears" -> Item.Shears(
params = params,
sprite = requireNotNull(loadSprite(dto)),
mobDamageMultiplier = dto.mobDamageMultiplier,
blockDamageMultiplier = dto.blockDamageMultiplier,
- level = requireNotNull(dto.toolLevel)
+ level = requireNotNull(dto.toolLevel),
)
- "block" -> Block(
+ "block" -> Item.Block(
params = params,
- block = requireNotNull(block)
+ block = requireNotNull(block),
)
- "slab" -> Slab(
+ "slab" -> Item.Slab(
params = params,
topPartBlock = requireNotNull(slabTopBlock),
- bottomPartBlock = requireNotNull(slabBottomBlock)
+ bottomPartBlock = requireNotNull(slabBottomBlock),
)
- "food" -> Food(
+ "food" -> Item.Food(
params = params,
sprite = requireNotNull(loadSprite(dto)),
- heal = requireNotNull(dto.heal)
+ heal = requireNotNull(dto.heal),
)
- "none" -> None(
- params = params
+ "none" -> Item.None(
+ params = params,
)
else -> throw IllegalArgumentException("Unknown item type ${dto.type}")
}
}
}
-
-}
\ No newline at end of file
+}
data class GameItemsDto(
@SerialName("blocks") val blocks: Map<String, BlockDto>,
@SerialName("items") val items: Map<String, ItemDto>,
-)
\ No newline at end of file
+)
dto = dto,
block = blocksMap[key],
slabTopBlock = blocksMap[dto.topSlabBlock] as? Block.Slab,
- slabBottomBlock = blocksMap[dto.bottomSlabBlock] as? Block.Slab
+ slabBottomBlock = blocksMap[dto.bottomSlabBlock] as? Block.Slab,
)
} catch (e: Exception) {
Gdx.app.error(TAG, "Failed to map item $key. Reason: ${e.message}")
jsonMap.forEach { (key, value) ->
craftingRecipes += CraftingRecipe(
input = value.input.map(::Regex),
- output = CraftingResult(getItemByKey(key), value.count)
+ output = CraftingResult(getItemByKey(key), value.count),
)
}
}
const val FALLBACK_BLOCK_KEY = "none"
const val FALLBACK_ITEM_KEY = "none"
}
-
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindMenuButtonsRepository(impl: MenuButtonRepositoryImpl): MenuButtonRepository
-
}
import ru.fredboy.cavedroid.data.menu.model.MenuButtonVisibilityDto
import ru.fredboy.cavedroid.domain.menu.model.MenuButton
import javax.inject.Inject
-import javax.inject.Singleton
@MenuScope
class MenuButtonMapper @Inject constructor() {
else -> dto.desktop
}
}
-}
\ No newline at end of file
+}
private val JsonFormat = Json { ignoreUnknownKeys = true }
}
-
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindSaveDataRepository(impl: SaveDataRepositoryImpl): SaveDataRepository
-
}
return SaveDataDto.ChestSaveDataDto(
version = SAVE_DATA_VERSION,
size = chest.size,
- items = chest.items.map(inventoryItemMapper::mapSaveData)
+ items = chest.items.map(inventoryItemMapper::mapSaveData),
)
}
return Chest(
fallbackItem = getFallbackItemUseCase(),
- initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem)
+ initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem),
)
}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
is Chest -> chestMapper.mapSaveData(container)
else -> null
}?.let { value -> key.toString() to value }
- }.toMap()
+ }.toMap(),
)
}
getItemByKeyUseCase = getItemByKeyUseCase,
containerWorldAdapter = containerWorldAdapter,
containerFactory = containerFactory,
- dropAdapter = dropAdapter
+ dropAdapter = dropAdapter,
).apply {
saveDataDto.containerMap.forEach { (key, value) ->
val container = when (value) {
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
value = when (direction) {
Player.ControlMode.WALK -> 0
Player.ControlMode.CURSOR -> 1
- }
+ },
)
}
private const val TAG = "ControlModeMapper"
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
value = when (direction) {
Direction.LEFT -> 0
Direction.RIGHT -> 1
- }
+ },
)
}
private const val TAG = "DirectionMapper"
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
@Reusable
class DropControllerMapper @Inject constructor(
private val dropMapper: DropMapper,
- private val itemsRepository: ItemsRepository
+ private val itemsRepository: ItemsRepository,
) {
fun mapSaveData(dropController: DropController): SaveDataDto.DropControllerSaveDataDto {
return SaveDataDto.DropControllerSaveDataDto(
version = SAVE_DATA_VERSION,
- drops = dropController.getAllDrop().map(dropMapper::mapSaveData)
+ drops = dropController.getAllDrop().map(dropMapper::mapSaveData),
)
}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-
-}
\ No newline at end of file
+}
velocityY = drop.velocity.y,
itemKey = drop.item.params.key,
amount = drop.amount,
- pickedUp = drop.isPickedUp
+ pickedUp = drop.isPickedUp,
)
}
x = saveDataDto.x,
y = saveDataDto.y,
item = getItemByKeyUseCase[saveDataDto.itemKey],
- amount = saveDataDto.amount
+ amount = saveDataDto.amount,
).apply {
width = saveDataDto.width
height = saveDataDto.height
companion object {
private const val SAVE_DATA_VERSION = 3
}
-
-}
\ No newline at end of file
+}
y = fallingBlock.y,
width = fallingBlock.width,
height = fallingBlock.height,
- velocityX = fallingBlock.velocity.x,
+ velocityX = fallingBlock.velocity.x,
velocityY = fallingBlock.velocity.y,
animDelta = fallingBlock.animDelta,
anim = fallingBlock.anim,
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
return SaveDataDto.InventoryItemSaveDataDto(
version = SAVE_DATA_VERSION,
itemKey = inventoryItem.item.params.key,
- amount = inventoryItem.amount
+ amount = inventoryItem.amount,
)
}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
return SaveDataDto.InventorySaveDataDto(
version = SAVE_DATA_VERSION,
size = inventory.size,
- items = inventory.items.map(inventoryItemMapper::mapSaveData)
+ items = inventory.items.map(inventoryItemMapper::mapSaveData),
)
}
return Inventory(
size = saveDataDto.size,
fallbackItem = getFallbackItem(),
- initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem)
+ initialItems = saveDataDto.items.map(inventoryItemMapper::mapInventoryItem),
)
}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
else -> null
}
},
- player = playerMapper.mapSaveData(mobController.player)
+ player = playerMapper.mapSaveData(mobController.player),
)
}
getFallbackItemUseCase = getFallbackItemUseCase,
mobWorldAdapter = mobWorldAdapter,
).apply {
- (mobs as MutableList).addAll(saveDataDto.mobs.mapNotNull { mob ->
- when (mob) {
- is SaveDataDto.PigSaveDataDto -> pigMapper.mapPig(mob)
- is SaveDataDto.FallingBlockSaveDataDto -> fallingBlockMapper.mapFallingBlock(mob)
- else -> null
- }
- })
+ (mobs as MutableList).addAll(
+ saveDataDto.mobs.mapNotNull { mob ->
+ when (mob) {
+ is SaveDataDto.PigSaveDataDto -> pigMapper.mapPig(mob)
+ is SaveDataDto.FallingBlockSaveDataDto -> fallingBlockMapper.mapFallingBlock(mob)
+ else -> null
+ }
+ },
+ )
player = playerMapper.mapPlayer(saveDataDto.player)
}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
@Reusable
class PigMapper @Inject constructor(
private val directionMapper: DirectionMapper,
- private val getPigSpriteUseCase: GetPigSpritesUseCase
+ private val getPigSpriteUseCase: GetPigSpritesUseCase,
) {
fun mapSaveData(pig: Pig): SaveDataDto.PigSaveDataDto {
y = pig.y,
width = pig.width,
height = pig.height,
- velocityX = pig.velocity.x,
+ velocityX = pig.velocity.x,
velocityY = pig.velocity.y,
animDelta = pig.animDelta,
anim = pig.anim,
canJump = pig.canJump,
flyMode = pig.isFlyMode,
maxHealth = pig.maxHealth,
- health = pig.health
+ health = pig.health,
)
}
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
y = player.y,
width = player.width,
height = player.height,
- velocityX = player.velocity.x,
+ velocityX = player.velocity.x,
velocityY = player.velocity.y,
animDelta = player.animDelta,
anim = player.anim,
getFallbackItem = getFallbackItemUseCase,
x = saveDataDto.x,
y = saveDataDto.y,
- behavior = PlayerMobBehavior()
+ behavior = PlayerMobBehavior(),
).apply {
width = saveDataDto.width
height = saveDataDto.height
companion object {
private const val SAVE_DATA_VERSION = 3
}
-}
\ No newline at end of file
+}
data class ChestSaveDataDto(
override val version: Int,
override val size: Int,
- override val items: List<InventoryItemSaveDataDto>
+ override val items: List<InventoryItemSaveDataDto>,
) : ContainerSaveDataDto()
@Serializable
override val velocityY: Float,
val itemKey: String,
val amount: Int,
- val pickedUp: Boolean
+ val pickedUp: Boolean,
) : RectangleObjectSaveDataDto()
@Serializable
data class DropControllerSaveDataDto(
override val version: Int,
- val drops: List<DropSaveDataDto>
+ val drops: List<DropSaveDataDto>,
) : SaveDataDto()
@Serializable
val mobs: List<@Contextual MobSaveDataDto>,
val player: PlayerSaveDataDto,
) : SaveDataDto()
-
-}
\ No newline at end of file
+}
private fun buildBlocksDictionary(
foreMap: Array<Array<Block>>,
- backMap: Array<Array<Block>>
+ backMap: Array<Array<Block>>,
): Map<String, Int> {
val maps = sequenceOf(foreMap.asSequence(), backMap.asSequence())
file.writeBytes(result, false)
}
-
private fun compressMap(map: Array<Array<Block>>, dict: Map<String, Int>): ByteArray {
if (dict.size > 0xff) {
throw IllegalArgumentException("Cannot save this map as bytes")
}
}
-
private fun internalLoadMap(
- savesPath: String
+ savesPath: String,
): Pair<Array<Array<Block>>, Array<Array<Block>>> {
val dict = Gdx.files.absolute("$savesPath$DICT_FILE").readString().split("\n")
dropController: DropController,
mobController: MobController,
containerController: ContainerController,
- gameWorld: GameWorld
+ gameWorld: GameWorld,
) {
val savesPath = "$gameDataFolder$SAVES_DIR"
gameDataFolder: String,
containerWorldAdapter: ContainerWorldAdapter,
containerFactory: ContainerFactory,
- dropAdapter: DropAdapter
+ dropAdapter: DropAdapter,
): ContainerController {
val savesPath = "$gameDataFolder$SAVES_DIR"
val containersFile = Gdx.files.absolute("$savesPath$CONTAINERS_FILE")
val containersBytes = containersFile.readBytes()
return ProtoBuf.decodeFromByteArray<SaveDataDto.ContainerControllerSaveDataDto>(
- containersBytes
+ containersBytes,
).let { saveData ->
containerControllerMapper.mapContainerController(
saveDataDto = saveData,
containerWorldAdapter = containerWorldAdapter,
containerFactory = containerFactory,
- dropAdapter = dropAdapter
+ dropAdapter = dropAdapter,
)
}
}
.let { saveData ->
dropControllerMapper.mapDropController(
saveDataDto = saveData,
- dropWorldAdapter = dropWorldAdapter
+ dropWorldAdapter = dropWorldAdapter,
)
}
}
.let { saveData ->
mobControllerMapper.mapMobController(
saveDataDto = saveData,
- mobWorldAdapter = mobWorldAdapter
+ mobWorldAdapter = mobWorldAdapter,
)
}
}
val savesPath = "$gameDataFolder$SAVES_DIR"
return Gdx.files.absolute("$savesPath$DROP_FILE").exists() &&
- Gdx.files.absolute("$savesPath$MOBS_FILE").exists() &&
- Gdx.files.absolute("$savesPath$CONTAINERS_FILE").exists() &&
- Gdx.files.absolute("$savesPath$DICT_FILE").exists() &&
- Gdx.files.absolute("$savesPath$FOREMAP_FILE").exists() &&
- Gdx.files.absolute("$savesPath$BACKMAP_FILE").exists()
+ Gdx.files.absolute("$savesPath$MOBS_FILE").exists() &&
+ Gdx.files.absolute("$savesPath$CONTAINERS_FILE").exists() &&
+ Gdx.files.absolute("$savesPath$DICT_FILE").exists() &&
+ Gdx.files.absolute("$savesPath$FOREMAP_FILE").exists() &&
+ Gdx.files.absolute("$savesPath$BACKMAP_FILE").exists()
}
companion object {
private const val FOREMAP_FILE = "/foremap.dat.gz"
private const val BACKMAP_FILE = "/backmap.dat.gz"
}
-}
\ No newline at end of file
+}
import dagger.Reusable
import ru.fredboy.cavedroid.domain.assets.model.MobSprite
import ru.fredboy.cavedroid.domain.assets.model.TouchButton
-import ru.fredboy.cavedroid.domain.assets.repository.*
+import ru.fredboy.cavedroid.domain.assets.repository.AssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.BlockAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.BlockDamageAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.FontAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.ItemsAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.TextureRegionsAssetsRepository
+import ru.fredboy.cavedroid.domain.assets.repository.TouchButtonsAssetsRepository
import javax.inject.Inject
@Reusable
private val itemsAssetsRepository: ItemsAssetsRepository,
private val mobAssetsRepository: MobAssetsRepository,
private val textureRegionsAssetsRepository: TextureRegionsAssetsRepository,
- private val touchButtonsAssetsRepository: TouchButtonsAssetsRepository
+ private val touchButtonsAssetsRepository: TouchButtonsAssetsRepository,
) {
private val repositories = sequenceOf(
itemsAssetsRepository,
mobAssetsRepository,
textureRegionsAssetsRepository,
- touchButtonsAssetsRepository
+ touchButtonsAssetsRepository,
)
fun initializeRepository() {
fun getTextureRegionByName(name: String): TextureRegion? {
return textureRegionsAssetsRepository.getTextureRegionByName(name)
}
-
}
data class Pig(
val headAndBody: Sprite,
- val leg: Sprite
+ val leg: Sprite,
) : MobSprite {
fun getLeftLegRelativeX(directionIndex: Int) = 9 - directionIndex * 9
fun getRightLegRelativeX(directionIndex: Int) = 21 - (9 * directionIndex)
fun getLegsRelativeY() = 12
-
}
-
-}
\ No newline at end of file
+}
data class TouchButton(
val rectangle: Rectangle,
val code: Int,
- val isMouse: Boolean
+ val isMouse: Boolean,
)
x: Int,
y: Int,
width: Int,
- height: Int
+ height: Int,
): TextureRegion {
return TextureRegion(texture, x, y + height, width, -height)
}
protected fun flippedSprite(
- texture: Texture
+ texture: Texture,
): Sprite {
return Sprite(texture).apply { flip(false, true) }
}
x: Int,
y: Int,
width: Int,
- height: Int
+ height: Int,
): Sprite {
return Sprite(flippedRegion(texture, x, y, width, height))
}
protected fun resolveTexture(
textureName: String,
lookupPath: String,
- cache: MutableMap<String, Texture>
+ cache: MutableMap<String, Texture>,
): Texture {
val cached = cache[textureName]
}
abstract fun initialize()
-
}
abstract class BlockAssetsRepository : AssetsRepository() {
abstract fun getBlockTexture(textureName: String): Texture
-
-}
\ No newline at end of file
+}
abstract val damageStages: Int
abstract fun getBlockDamageSprite(stage: Int): Sprite
-
}
abstract fun getStringHeight(string: String): Float
abstract fun getFont(): BitmapFont
-}
\ No newline at end of file
+}
abstract class ItemsAssetsRepository : AssetsRepository() {
abstract fun getItemTexture(textureName: String): Texture
-
}
abstract fun getPlayerSprites(): MobSprite.Player
abstract fun getPigSprites(): MobSprite.Pig
-
-}
\ No newline at end of file
+}
abstract class TextureRegionsAssetsRepository : AssetsRepository() {
abstract fun getTextureRegionByName(name: String): TextureRegion?
-
}
abstract class TouchButtonsAssetsRepository : AssetsRepository() {
abstract fun getTouchButtons(): Map<String, TouchButton>
-
-}
\ No newline at end of file
+}
@Reusable
class DisposeAssetsUseCase @Inject constructor(
- private val gameAssetsHolder: GameAssetsHolder
+ private val gameAssetsHolder: GameAssetsHolder,
) {
operator fun invoke() {
gameAssetsHolder.dispose()
}
-
-}
\ No newline at end of file
+}
operator fun invoke(): Int {
return gameAssetsHolder.getBlockDamageFrameCount()
}
-
}
operator fun get(stage: Int): Sprite {
return gameAssetsHolder.getBlockDamageSprite(stage)
}
-
}
@Reusable
class GetBlockTextureUseCase @Inject constructor(
- private val gameAssetsHolder: GameAssetsHolder
+ private val gameAssetsHolder: GameAssetsHolder,
) {
operator fun get(name: String): Texture {
return gameAssetsHolder.getBlockTexture(name)
}
-
-}
\ No newline at end of file
+}
operator fun invoke(): BitmapFont {
return gameAssetsHolder.getFont()
}
-
}
@Reusable
class GetItemTextureUseCase @Inject constructor(
- private val gameAssetsHolder: GameAssetsHolder
+ private val gameAssetsHolder: GameAssetsHolder,
) {
operator fun get(name: String): Texture {
return gameAssetsHolder.getItemTexture(name)
}
-
-}
\ No newline at end of file
+}
operator fun invoke(): MobSprite.Pig {
return gameAssetsHolder.getPigSprites()
}
-
}
operator fun invoke(): MobSprite.Player {
return gameAssetsHolder.getPlayerSprites()
}
-
}
operator fun invoke(string: String): Float {
return gameAssetsHolder.getStringHeight(string)
}
-
-}
\ No newline at end of file
+}
operator fun invoke(string: String): Float {
return gameAssetsHolder.getStringWidth(string)
}
-
-}
\ No newline at end of file
+}
operator fun get(name: String): TextureRegion? {
return gameAssetsHolder.getTextureRegionByName(name)
}
-
}
operator fun invoke(): Map<String, TouchButton> {
return gameAssetsHolder.getTouchButtons()
}
-
}
operator fun invoke() {
gameAssetsHolder.initializeRepository()
}
-
-}
\ No newline at end of file
+}
fun getViewportCoordinates(x: Int, y: Int): Pair<Float, Float> {
return xOnViewport(x) to yOnViewport(y)
}
-}
\ No newline at end of file
+}
fun useDynamicCamera(): Boolean
-
fun getGameDirectory(): String
fun getWidth(): Float
fun setWidth(width: Float)
fun setHeight(height: Float)
-
-}
\ No newline at end of file
+}
fun setJoystick(joystick: Joystick)
fun setCameraContext(cameraContext: CameraContext)
-
}
/* x = */ x + params.spriteMargins.left,
/* y = */ y + params.spriteMargins.top,
/* width = */ spriteWidth,
- /* height = */ spriteHeight
+ /* height = */ spriteHeight,
)
draw(spriter)
}
}
-
+
fun isFluid(): Boolean {
contract { returns(true) implies (this@Block is Fluid) }
return this is Fluid
/* x = */ x * BLOCK_SIZE_PX + params.collisionMargins.left,
/* y = */ y * BLOCK_SIZE_PX + params.collisionMargins.top,
/* width = */ width,
- /* height = */ height
+ /* height = */ height,
)
}
sealed class Container() : Block()
data class None(
- override val params: CommonBlockParams
+ override val params: CommonBlockParams,
) : Block()
data class Normal(
data class Furnace(
override val params: CommonBlockParams,
- ): Container() {
+ ) : Container() {
override val sprite: Sprite
get() = getSprite(false)
/* x = */ x + params.spriteMargins.left,
/* y = */ y + params.spriteMargins.top,
/* width = */ spriteWidth,
- /* height = */ spriteHeight
+ /* height = */ spriteHeight,
)
draw(spriter)
}
}
-
}
data class Chest(
- override val params: CommonBlockParams
- ): Container()
+ override val params: CommonBlockParams,
+ ) : Container()
data class Slab(
override val params: CommonBlockParams,
val fullBlockKey: String,
val otherPartBlockKey: String,
- ): Block()
+ ) : Block()
- sealed class Fluid: Block() {
+ sealed class Fluid : Block() {
abstract val state: Int
}
-
+
data class Water(
override val params: CommonBlockParams,
override val state: Int,
companion object {
private const val ANIMATION_FRAME_DURATION_MS = 100L
}
-}
\ No newline at end of file
+}
package ru.fredboy.cavedroid.domain.items.model.block
data class BlockAnimationInfo(
- val framesCount: Int
+ val framesCount: Int,
)
val left: Int,
val top: Int,
val right: Int,
- val bottom: Int
+ val bottom: Int,
) {
init {
assert(left + right < 16)
assert(top + bottom < 16)
}
-
}
data class CraftingRecipe(
val input: List<Regex>,
- val output: CraftingResult
+ val output: CraftingResult,
)
class Inventory @JvmOverloads constructor(
val size: Int,
private val fallbackItem: Item.None,
- initialItems: List<InventoryItem>? = null
+ initialItems: List<InventoryItem>? = null,
) {
private val _items: Array<InventoryItem> = Array(size) { index ->
destination = _items,
destinationOffset = 1,
startIndex = 0,
- endIndex = size - 1
+ endIndex = size - 1,
)
_items[0] = item.toInventoryItem(item.params.maxStack)
companion object {
private const val SAVE_DATA_VERSION = 1
}
-}
\ No newline at end of file
+}
font: BitmapFont,
text: String,
x: Float,
- y: Float
+ y: Float,
) {
spriteBatch.drawString(font, text, x + 1, y + 1, Color.BLACK)
spriteBatch.drawString(font, text, x, y, Color.WHITE)
font = font,
text = amountString,
x = x + 10f - getStringWidth(amountString) + 1f,
- y = y + 10f - getStringHeight(amountString) + 1f
+ y = y + 10f - getStringHeight(amountString) + 1f,
)
}
/* x = */ x,
/* y = */ y + 1.px - 2,
/* width = */ 1.px * (amount.toFloat() / item.params.maxStack.toFloat()),
- /* height = */ 2f
+ /* height = */ 2f,
)
shapeRenderer.end()
spriteBatch.begin()
font = font,
text = amountString,
x = x + 1.px - getStringWidth(amountString),
- y = y + 1.px - getStringHeight(amountString)
+ y = y + 1.px - getStringHeight(amountString),
)
}
}
return this?.item == null || this.item.isNone()
}
}
-
}
data class Normal(
override val params: CommonItemParams,
- override val sprite: Sprite
+ override val sprite: Sprite,
) : Item()
sealed class Tool : Item() {
data class None(
override val params: CommonItemParams,
- ): Item() {
+ ) : Item() {
override val sprite: Sprite
get() = throw IllegalAccessException("Trying to get sprite of None")
}
data class Usable(
override val params: CommonItemParams,
override val sprite: Sprite,
- val useActionKey: String
+ val useActionKey: String,
) : Item()
data class Block(
override val params: CommonItemParams,
- override val block: DomainBlockModel
+ override val block: DomainBlockModel,
) : Placeable()
data class Slab(
override val params: CommonItemParams,
val topPartBlock: DomainBlockModel.Slab,
- val bottomPartBlock: DomainBlockModel.Slab
+ val bottomPartBlock: DomainBlockModel.Slab,
) : Placeable() {
override val block get() = bottomPartBlock
}
override val sprite: Sprite,
val heal: Int,
) : Item()
-
-}
\ No newline at end of file
+}
fun getCraftingResult(input: List<Item>): InventoryItem
fun getAllItems(): Collection<Item>
-
}
operator fun invoke() {
itemsRepository.dispose()
}
-
-}
\ No newline at end of file
+}
operator fun get(key: String): Block {
return itemsRepository.getBlockByKey(key)
}
-
}
operator fun <T : Block> get(type: Class<T>): List<T> {
return itemsRepository.getBlocksByType(type)
}
-
}
operator fun get(input: List<Item>): InventoryItem {
return itemsRepository.getCraftingResult(input)
}
-
}
operator fun invoke(): Block.None {
return itemsRepository.fallbackBlock
}
-
-}
\ No newline at end of file
+}
@Reusable
class GetFallbackItemUseCase @Inject constructor(
- private val itemsRepository: ItemsRepository
+ private val itemsRepository: ItemsRepository,
) {
operator fun invoke(): Item.None {
return itemsRepository.fallbackItem
}
-
-}
\ No newline at end of file
+}
operator fun get(index: Int): Item {
return itemsRepository.getItemByIndex(index)
}
-
}
operator fun get(key: String): Item {
return itemsRepository.getItemByKey(key)
}
-
-}
\ No newline at end of file
+}
operator fun invoke() {
itemsRepository.initialize()
}
-
}
abstract val actionKey: String
abstract val isEnabled: Boolean
-
data class Simple(
override val label: String,
override val isVisible: Boolean,
fun getCurrentMenuButtons(): Map<String, MenuButton>?
fun setButtonEnabled(menuKey: String, buttonKey: String, enabled: Boolean)
-
-}
\ No newline at end of file
+}
class GameMapSaveData(
private var foreMap: Array<Array<Block>>?,
- private var backMap: Array<Array<Block>>?
+ private var backMap: Array<Array<Block>>?,
) {
fun retrieveForeMap(): Array<Array<Block>> {
val value = requireNotNull(foreMap)
fun isEmpty(): Boolean {
return mobController == null &&
- dropController == null &&
- containerController == null
+ dropController == null &&
+ containerController == null
}
-}
\ No newline at end of file
+}
dropController: DropController,
mobController: MobController,
containerController: ContainerController,
- gameWorld: GameWorld
+ gameWorld: GameWorld,
)
fun loadMap(
- gameDataFolder: String
+ gameDataFolder: String,
): GameMapSaveData
fun loadContainerController(
): MobController
fun exists(gameDataFolder: String): Boolean
-
-}
\ No newline at end of file
+}
fun interface OnBlockDestroyedListener {
fun onBlockDestroyed(block: Block, x: Int, y: Int, layer: Layer, withDrop: Boolean)
-
-}
\ No newline at end of file
+}
fun interface OnBlockPlacedListener {
fun onBlockPlaced(block: Block, x: Int, y: Int, layer: Layer)
-
-}
\ No newline at end of file
+}
enum class Layer(val z: Int) {
FOREGROUND(0),
- BACKGROUND(1)
+ BACKGROUND(1),
}
interface ContainerFactory {
fun createContainer(type: Block.Container): Container
-}
\ No newline at end of file
+}
fun checkContainerAtCoordinates(
coordinates: ContainerCoordinates,
- requiredType: KClass<out Block.Container>
+ requiredType: KClass<out Block.Container>,
): Boolean
fun addOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
fun removeOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
fun removeOnBlockPlacedListener(listener: OnBlockPlacedListener)
-
-}
\ No newline at end of file
+}
) : Container(
size = SIZE,
fallbackItem = fallbackItem,
- initialItems = initialItems
+ initialItems = initialItems,
) {
override val type get() = Block.Chest::class
abstract class Container(
val size: Int,
protected val fallbackItem: Item.None,
- initialItems: List<InventoryItem>? = null
+ initialItems: List<InventoryItem>? = null,
) {
val inventory = Inventory(size, fallbackItem, initialItems)
abstract val type: KClass<out Block.Container>
abstract fun update(itemByKey: GetItemByKeyUseCase)
-
-}
\ No newline at end of file
+}
)
}
}
-}
\ No newline at end of file
+}
class Furnace(
fallbackItem: Item.None,
- initialItems: List<InventoryItem>? = null
+ initialItems: List<InventoryItem>? = null,
) : Container(
size = SIZE,
fallbackItem = fallbackItem,
field = MathUtils.clamp(value, 0f, 1f)
}
-
fun canSmelt(): Boolean {
return (result.isNoneOrNull() || (result.item.params.key == input.item.params.smeltProductKey)) &&
- !input.isNoneOrNull() && input.item.params.smeltProductKey != null &&
- (!fuel.isNoneOrNull() || burnProgress > 0f)
+ !input.isNoneOrNull() && input.item.params.smeltProductKey != null &&
+ (!fuel.isNoneOrNull() || burnProgress > 0f)
}
private fun startBurning() {
burnProgress += 0.01f
startBurnTimeMs = TimeUtils.millis()
}
-
}
if (currentFuel?.isNone() == false && burnProgress >= 1f) {
const val SMELTING_TIME_MS = 10000L
}
-
-}
\ No newline at end of file
+}
fun dropInventory(x: Float, y: Float, inventory: Inventory)
fun dropItems(x: Float, y: Float, items: List<InventoryItem>)
-
-}
\ No newline at end of file
+}
fun removeOnBlockDestroyedListener(listener: OnBlockDestroyedListener)
fun removeOnBlockPlacedListener(listener: OnBlockPlacedListener)
-
-}
\ No newline at end of file
+}
)
}
-
companion object {
private fun getInitialVelocity(): Vector2 = Vector2(MathUtils.random(-100f, 100f), -100f)
const val MAGNET_VELOCITY = 256f
const val DROP_SIZE = BLOCK_SIZE_PX / 2
}
-
-}
\ No newline at end of file
+}
interface MobBehavior {
fun update(mob: Mob, worldAdapter: MobWorldAdapter, delta: Float)
-
-}
\ No newline at end of file
+}
fun destroyBackgroundBlock(x: Int, y: Int, shouldDrop: Boolean)
fun findSpawnPoint(): Vector2
-
-}
\ No newline at end of file
+}
val width: Float
val height: Float
-}
\ No newline at end of file
+}
val basis: Int,
) {
LEFT(0, -1),
- RIGHT(1, 1);
+ RIGHT(1, 1),
+ ;
companion object {
fun random() = if (MathUtils.randomBoolean()) LEFT else RIGHT
x: Float,
y: Float,
behavior: MobBehavior,
-) : Mob(x, y, 1.px, 1.px, Direction.RIGHT, Int.MAX_VALUE , behavior) {
+) : Mob(x, y, 1.px, 1.px, Direction.RIGHT, Int.MAX_VALUE, behavior) {
init {
velocity.y = 1f
spriteBatch: SpriteBatch,
x: Float,
y: Float,
- delta: Float
+ delta: Float,
) {
block.draw(spriteBatch, x, y)
}
-
-}
\ No newline at end of file
+}
val middleMapY get() = (y + height / 2).bl
val lowerMapY get() = (y + height).bl
- var animDelta = ANIMATION_SPEED;
+ var animDelta = ANIMATION_SPEED
var anim = 0f
var isDead = false
/* x = */ x - HIT_RANGE,
/* y = */ y + HIT_RANGE,
/* width = */ width + HIT_RANGE * 2f,
- /* height = */ height + HIT_RANGE * 2f
+ /* height = */ height + HIT_RANGE * 2f,
)
}
}
open fun getDropItems(
- itemByKey: GetItemByKeyUseCase
+ itemByKey: GetItemByKeyUseCase,
): List<InventoryItem> {
return emptyList()
}
protected const val ANIMATION_RANGE = 60f
- private const val HIT_RANGE = 8f;
+ private const val HIT_RANGE = 8f
private const val DAMAGE_TINT_TIMEOUT_S = 0.5f
private val DAMAGE_TINT_COLOR = Color((0xff8080 shl 8) or 0xFF)
-
}
-}
\ No newline at end of file
+}
) : Mob(x, y, WIDTH, HEIGHT, Direction.random(), MAX_HEALTH, behavior) {
override val speed get() = SPEED
-
+
override fun changeDir() {
switchDir()
velocity = Vector2(direction.basis * speed, 0f)
spriteBatch: SpriteBatch,
x: Float,
y: Float,
- delta: Float
+ delta: Float,
) {
updateAnimation(delta)
spriteBatch.drawSprite(sprite.leg, leftLegX, legY, anim, tint = tintColor)
spriteBatch.drawSprite(sprite.leg, rightLegX, legY, anim, tint = tintColor)
}
-
+
companion object {
private const val WIDTH = 25f
private const val HEIGHT = 18f
- private const val SPEED = 48f
+ private const val SPEED = 48f
private const val JUMP_VELOCITY = -133.332f
private const val MAX_HEALTH = 10
}
-}
\ No newline at end of file
+}
var activeSlot
get() = _activeSlot
set(value) {
- if (value in 0 ..< HOTBAR_SIZE) {
+ if (value in 0..<HOTBAR_SIZE) {
_activeSlot = value
}
}
val spriteOrigin = item.params.inHandSpriteOrigin
val handMultiplier = -direction.basis
val xOffset = (-1 + direction.index) * itemSprite.width + SMALL_ITEM_SIZE / 2 +
- handMultiplier * itemSprite.width * spriteOrigin.x
- val yOffset = if (!isSmallSprite) - itemSprite.height / 2 else 0f
+ handMultiplier * itemSprite.width * spriteOrigin.x
+ val yOffset = if (!isSmallSprite) -itemSprite.height / 2 else 0f
val rotate = handAnim + HAND_ITEM_ANGLE_DEG
itemSprite.setPosition(itemX, itemY)
itemSprite.draw(spriteBatch)
-
// dont forget to reset
itemSprite.setFlip(false, itemSprite.isFlipY)
itemSprite.rotation = 0f
enum class ControlMode {
WALK,
- CURSOR
+ CURSOR,
}
companion object {
private val SMALL_ITEM_SIZE = 8f
private val HAND_ITEM_ANGLE_DEG = 30f
}
-}
\ No newline at end of file
+}
private val containerWorldAdapter: ContainerWorldAdapter,
private val containerFactory: ContainerFactory,
private val dropAdapter: DropAdapter,
-): OnBlockPlacedListener, OnBlockDestroyedListener {
+) : OnBlockPlacedListener, OnBlockDestroyedListener {
val containerMap = mutableMapOf<ContainerCoordinates, Container>()
companion object {
private const val TAG = "ContainerControllerImpl"
}
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindContainerFactory(impl: ContainerFactoryImpl): ContainerFactory
-
-}
\ No newline at end of file
+}
@GameScope
internal class ContainerFactoryImpl @Inject constructor(
private val getFallbackItemUseCase: GetFallbackItemUseCase,
-): ContainerFactory {
+) : ContainerFactory {
override fun createContainer(type: Block.Container): Container {
return when (type) {
fallbackItem = getFallbackItemUseCase(),
)
}
-
-}
\ No newline at end of file
+}
constructor(
itemsRepository: ItemsRepository,
dropWorldAdapter: DropWorldAdapter,
- initialDrop: Collection<Drop>
+ initialDrop: Collection<Drop>,
) : this(itemsRepository, dropWorldAdapter) {
drops.addAll(initialDrop.filterNot { drop -> drop.item.isNone() })
}
val iterator = drops.iterator()
while (iterator.hasNext()) {
- val drop = iterator.next();
+ val drop = iterator.next()
if (drop.isPickedUp) {
iterator.remove()
}
x = x.blockCenterPx() - Drop.DROP_SIZE / 2,
y = y.blockCenterPx() - Drop.DROP_SIZE / 2,
item = item,
- count = dropInfo.count
+ count = dropInfo.count,
)
}
-
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindDropAdapter(impl: DropAdapterImpl): DropAdapter
-
-}
\ No newline at end of file
+}
override fun dropItems(x: Float, y: Float, items: List<InventoryItem>) {
items.forEach { item -> dropController.addDrop(x, y, item) }
}
-
-}
\ No newline at end of file
+}
getFallbackItem = getFallbackItemUseCase,
x = 0f,
y = 0f,
- behavior = PlayerMobBehavior()
+ behavior = PlayerMobBehavior(),
)
init {
companion object {
private const val SURVIVAL_CURSOR_RANGE = 4
}
-}
\ No newline at end of file
+}
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 ru.fredboy.cavedroid.entity.mob.model.Mob
import kotlin.reflect.KClass
abstract class BaseMobBehavior<MOB : Mob>(
}
} else {
throw IllegalArgumentException(
- "Trying to update mob of type ${mob::class.simpleName} with behavior of ${mobType.simpleName}"
+ "Trying to update mob of type ${mob::class.simpleName} with behavior of ${mobType.simpleName}",
)
}
}
companion object {
private const val TAG = "BaseMobBehavior"
}
-}
\ No newline at end of file
+}
kill()
}
}
-
-}
\ No newline at end of file
+}
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
+import ru.fredboy.cavedroid.entity.mob.model.Pig
class PigMobBehavior : BaseMobBehavior<Pig>(
mobType = Pig::class,
}
}
}
-
-}
\ No newline at end of file
+}
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
+import ru.fredboy.cavedroid.entity.mob.model.Player
class PlayerMobBehavior : BaseMobBehavior<Player>(
mobType = Player::class,
var blockDamageMultiplier = 1f
(activeItem.item as? Item.Tool)?.let { currentTool ->
if (currentTool.javaClass == targetBlock.params.toolType &&
- currentTool.level >= targetBlock.params.toolLevel) {
+ currentTool.level >= targetBlock.params.toolLevel
+ ) {
blockDamageMultiplier = 2f * currentTool.level
}
blockDamageMultiplier *= currentTool.blockDamageMultiplier
blockDamage += 60f * delta * blockDamageMultiplier
}
}
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindPlayerAdapter(impl: PlayerAdapterImpl): PlayerAdapter
-}
\ No newline at end of file
+}
return fallingBlock
}
-
-}
\ No newline at end of file
+}
return pig
}
-
-}
\ No newline at end of file
+}
override val height: Float
get() = player.height
-}
\ No newline at end of file
+}
SURVIVAL_INVENTORY,
CHEST,
CRAFTING_TABLE,
- FURNACE
-}
\ No newline at end of file
+ FURNACE,
+}
const val contentsInRow = 9
const val contentsInCol = 3
}
-}
\ No newline at end of file
+}
currentWindow = null
tooltipManager.showMouseTooltip("")
}
-
-}
\ No newline at end of file
+}
companion object {
private const val TOOLTIP_TIME_S = 2f
}
-
-}
\ No newline at end of file
+}
items: MutableList<InventoryItem>,
itemsRepository: ItemsRepository,
index: Int,
- pointer: Int = -1
+ pointer: Int = -1,
) {
if (selectedItem != null &&
selectedItem?.item?.isNone() != true &&
if (selectedItem == null ||
(!clickedItem.isNoneOrNull() && selectedItem.item != clickedItem.item) ||
- !clickedItem.canBeAdded()) {
+ !clickedItem.canBeAdded()
+ ) {
return
}
val newItem = selectedItem.item.toInventoryItem(
- (clickedItem.takeIf { !it.item.isNone() }?.amount ?: 0) + 1
+ (clickedItem.takeIf { !it.item.isNone() }?.amount ?: 0) + 1,
)
items[index] = newItem
selectedItem.amount--
this@AbstractInventoryWindow.selectedItem = null
}
}
-
-}
\ No newline at end of file
+}
set(value) {
craftResultList[0] = value
}
-
-}
\ No newline at end of file
+}
override val type = GameWindowType.CHEST
override var selectedItem: InventoryItem? = null
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.game.window.GameWindowType
class CraftingInventoryWindow(
- itemsRepository: ItemsRepository
+ itemsRepository: ItemsRepository,
) : AbstractInventoryWindowWithCraftGrid(itemsRepository) {
override val type = GameWindowType.CRAFTING_TABLE
override var selectedItem: InventoryItem? = null
-}
\ No newline at end of file
+}
fun getMaxScroll(itemsRepository: ItemsRepository): Int {
return itemsRepository.getAllItems().size / GameWindowsConfigs.Creative.itemsInRow
}
-}
\ No newline at end of file
+}
override val type = GameWindowType.FURNACE
override var selectedItem: InventoryItem? = null
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.game.window.GameWindowType
class SurvivalInventoryWindow(
- itemsRepository: ItemsRepository
+ itemsRepository: ItemsRepository,
) : AbstractInventoryWindowWithCraftGrid(itemsRepository) {
override val type = GameWindowType.SURVIVAL_INVENTORY
override var selectedItem: InventoryItem? = null
-}
\ No newline at end of file
+}
onBlockDestroyedListeners.removeFirst { it.get() == listener }
}
-
private fun transformX(x: Int): Int {
var transformed = x % width
if (transformed < 0) {
private fun getMap(x: Int, y: Int, layer: Layer): Block {
val fallback = itemsRepository.fallbackBlock
- if (y !in 0 ..< height) {
+ if (y !in 0..<height) {
return fallback
}
val transformedX = transformX(x)
- if (transformedX !in 0 ..< width) {
+ if (transformedX !in 0..<width) {
return fallback
}
}
private fun setMap(x: Int, y: Int, layer: Layer, value: Block, dropOld: Boolean) {
- if (y !in 0 ..< height) {
+ if (y !in 0..<height) {
return
}
val transformedX = transformX(x)
- if (transformedX !in 0 ..< width) {
+ if (transformedX !in 0..<width) {
return
}
private fun isSameSlab(slab1: Block, slab2: Block): Boolean {
return slab1 is Block.Slab && slab2 is Block.Slab &&
- (slab1.params.key == slab2.otherPartBlockKey || slab1.otherPartBlockKey == slab2.params.key)
+ (slab1.params.key == slab2.otherPartBlockKey || slab1.otherPartBlockKey == slab2.params.key)
}
fun hasForeAt(x: Int, y: Int): Boolean {
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())) {
+ (!value.params.isTransparent || value.params.key == "glass" || value.isChest() || value.isSlab())
+ ) {
setBackMap(x, y, value, dropOld)
true
} else {
companion object {
private const val TAG = "GameWorld"
}
-}
\ No newline at end of file
+}
@Binds
internal abstract fun bindDropWorldAdapter(impl: WorldAdapterImpl): DropWorldAdapter
-}
\ No newline at end of file
+}
enum class Biome {
PLAINS,
DESERT,
- WINTER
-}
\ No newline at end of file
+ WINTER,
+}
private val biomesMap by lazy { generateBiomes() }
private val plainsPlants = listOf("dandelion", "rose", "tallgrass")
- private val mushrooms = listOf("mushroom_brown", "mushroom_red",)
+ private val mushrooms = listOf("mushroom_brown", "mushroom_red")
private fun generateHeights(): IntArray {
- val surfaceHeightRange = config.minSurfaceHeight .. config.maxSurfaceHeight
+ val surfaceHeightRange = config.minSurfaceHeight..config.maxSurfaceHeight
val result = IntArray(config.width)
result[0] = surfaceHeightRange.random(random)
- for (x in 1 ..< config.width) {
+ for (x in 1..<config.width) {
val previous = result[x - 1]
var d = random.nextInt(-5, 6).let { if (it !in -4..4) it / abs(it) else 0 }
- if (previous + d !in surfaceHeightRange) { d = -d }
+ if (previous + d !in surfaceHeightRange) {
+ d = -d
+ }
if (result.lastIndex - x < abs(result[0] - previous) * 3) {
d = result[0].compareTo(previous).let { if (it != 0) it / abs(it) else 0 }
}
private fun winterBiome(x: Int) {
- assert(x in 0 ..< config.width) { "x not in range of world width" }
+ assert(x in 0..<config.width) { "x not in range of world width" }
val surfaceHeight = heights[x]
foreMap[x][surfaceHeight - 1] = snow
}
- for (y in min(surfaceHeight + 1, config.seaLevel) ..< config.height - 1) {
+ for (y in min(surfaceHeight + 1, config.seaLevel)..<config.height - 1) {
if (y <= surfaceHeight) {
backMap[x][y] = dirt
continue
}
private fun plainsBiome(x: Int) {
- assert(x in 0 ..< config.width) { "x not in range of world width" }
+ assert(x in 0..<config.width) { "x not in range of world width" }
val surfaceHeight = heights[x]
backMap[x][surfaceHeight] = grass
backMap[x][config.height - 1] = bedrock
- for (y in min(surfaceHeight + 1, config.seaLevel) ..< config.height - 1) {
+ for (y in min(surfaceHeight + 1, config.seaLevel)..<config.height - 1) {
if (y <= surfaceHeight) {
backMap[x][y] = dirt
continue
}
private fun desertBiome(x: Int) {
- assert(x in 0 ..< config.width) { "x not in range of world width" }
+ assert(x in 0..<config.width) { "x not in range of world width" }
val surfaceHeight = heights[x]
val sandstone = itemsRepository.getBlockByKey("sandstone")
val stone = itemsRepository.getBlockByKey("stone")
-
foreMap[x][surfaceHeight] = sand
foreMap[x][config.height - 1] = bedrock
backMap[x][surfaceHeight] = sand
backMap[x][config.height - 1] = bedrock
- for (y in min(surfaceHeight + 1, config.seaLevel) ..< config.height - 1) {
+ for (y in min(surfaceHeight + 1, config.seaLevel)..<config.height - 1) {
if (y <= surfaceHeight) {
backMap[x][y] = sand
continue
private fun fillWater() {
val water = itemsRepository.getBlockByKey("water")
- for (x in 0 ..< config.width) {
- for (y in config.seaLevel ..< config.height) {
+ for (x in 0..<config.width) {
+ for (y in config.seaLevel..<config.height) {
if (!foreMap[x][y].isNone()) {
break
}
backMap[x][top] = leaves
}
- for (x1 in max(0, x - 1) .. min(config.width - 1, x + 1)) {
- for (y in height .. height + treeH - 4) {
+ for (x1 in max(0, x - 1)..min(config.width - 1, x + 1)) {
+ for (y in height..height + treeH - 4) {
foreMap[x1][y] = leaves
backMap[x1][y] = leaves
}
backMap[x][top] = leaves
}
- for (x1 in max(0, x - 1) .. min(config.width - 1, x + 1)) {
+ for (x1 in max(0, x - 1)..min(config.width - 1, x + 1)) {
val y = height
foreMap[x1][y] = leaves
backMap[x1][y] = leaves
}
for (y in 1..2) {
- for (x1 in max(0, x - y) .. min(config.width - 1, x + y)) {
+ for (x1 in max(0, x - y)..min(config.width - 1, x + y)) {
foreMap[x1][height + 1 + y] = leaves
backMap[x1][height + 1 + y] = leaves
}
}
}
- private fun generateOres(x : Int) {
+ private fun generateOres(x: Int) {
val stone = itemsRepository.getBlockByKey("stone")
val coal = itemsRepository.getBlockByKey("coal_ore")
val iron = itemsRepository.getBlockByKey("iron_ore")
val diamond = itemsRepository.getBlockByKey("diamond_ore")
val lapis = itemsRepository.getBlockByKey("lapis_ore")
- for (y in heights[x] ..< config.height) {
+ for (y in heights[x]..<config.height) {
val res = random.nextInt(10000)
val h = config.height - y
val block = when {
res in 0..<25 && h < 16 -> diamond
- res in 25 ..< 50 && h < 32 -> gold
- res in 50 ..< 250 && h < 64 -> iron
- res in 250 ..< 450 && h < 128 -> coal
- res in 450 ..< (450 + (25 - (abs(h - 16) * (25 / 16)))) -> lapis
+ res in 25..<50 && h < 32 -> gold
+ res in 50..<250 && h < 64 -> iron
+ res in 250..<450 && h < 128 -> coal
+ res in 450..<(450 + (25 - (abs(h - 16) * (25 / 16)))) -> lapis
else -> null
}
return Pair(foreMap, backMap)
}
-
}
seaLevel = 192,
)
}
-
}
-
}
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.entity.mob.model.Player
import ru.fredboy.cavedroid.game.world.GameWorld
import javax.inject.Inject
import kotlin.reflect.KClass
while (y++ in 0..gameWorld.generatorConfig.seaLevel) {
if (y == gameWorld.generatorConfig.seaLevel) {
- while (x++ in 0 ..< width) {
+ while (x++ in 0..<width) {
if (getForegroundBlock(x, y).params.hasCollision) {
break
} else if (x == width - 1) {
override fun checkContainerAtCoordinates(
coordinates: ContainerCoordinates,
- requiredType: KClass<out Block.Container>
+ requiredType: KClass<out Block.Container>,
): Boolean {
val block = when (coordinates.z) {
Layer.FOREGROUND.z -> gameWorld.getForeMap(coordinates.x, coordinates.y)
override fun removeOnBlockPlacedListener(listener: OnBlockPlacedListener) {
gameWorld.removeBlockPlacedListener(listener)
}
-}
\ No newline at end of file
+}
/* x = */ applicationContextRepository.getWidth() / 2,
/* y = */ 0f,
/* width = */ applicationContextRepository.getWidth() / 2,
- /* height = */ applicationContextRepository.getHeight() / 2
+ /* height = */ applicationContextRepository.getHeight() / 2,
),
Input.Buttons.LEFT,
- true
+ true,
)
private val mouseRightTouchButton = TouchButton(
/* x = */ applicationContextRepository.getWidth() / 2,
/* y = */ applicationContextRepository.getHeight() / 2,
/* width = */ applicationContextRepository.getWidth() / 2,
- /* height = */ applicationContextRepository.getHeight() / 2
+ /* height = */ applicationContextRepository.getHeight() / 2,
),
Input.Buttons.RIGHT,
- true
+ true,
)
private var touchDownX = 0f
private var touchDownY = 0f
-
override fun keyDown(keycode: Int): Boolean {
return handleKeyboardAction(keycode, true)
}
}
override fun keyTyped(p0: Char): Boolean {
- return false;
+ return false
}
override fun touchDown(screenX: Int, screenY: Int, pointer: Int, button: Int): Boolean {
mouseY = screenY,
button = touchedKey.code,
touchUp = true,
- pointer = pointer
+ pointer = pointer,
)
} else {
keyUp(touchedKey.code)
return handleMouseAction(action)
}
-
@Suppress("unused")
fun update(delta: Float) {
handleMousePosition()
private val nullButton = TouchButton(Rectangle(), -1, true)
}
-}
\ No newline at end of file
+}
package ru.fredboy.cavedroid.ux.controls.action
import com.badlogic.gdx.Gdx
+import ru.fredboy.cavedroid.domain.items.model.item.Item
import ru.fredboy.cavedroid.ux.controls.action.placeblock.IPlaceBlockAction
import ru.fredboy.cavedroid.ux.controls.action.placeblock.PlaceBlockItemToBackgroundAction
import ru.fredboy.cavedroid.ux.controls.action.placeblock.PlaceBlockItemToForegroundAction
-import ru.fredboy.cavedroid.domain.items.model.item.Item
private const val TAG = "PlaceBlockActionUtils"
@BindsIntoMapStringKey(
interfaceClass = IPlaceBlockAction::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "PlaceBlockActionsModule"
+ moduleName = "PlaceBlockActionsModule",
)
annotation class BindPlaceBlockAction(val stringKey: String)
@BindsIntoMapStringKey(
interfaceClass = IUseBlockAction::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "UseBlockActionsModule"
+ moduleName = "UseBlockActionsModule",
)
annotation class BindUseBlockAction(val stringKey: String)
@BindsIntoMapStringKey(
interfaceClass = IUseItemAction::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "UseItemActionsModule"
+ moduleName = "UseItemActionsModule",
)
annotation class BindUseItemAction(val stringKey: String)
interface IPlaceBlockAction {
fun place(placeable: Item.Placeable, x: Int, y: Int)
-
}
companion object {
const val ACTION_KEY = "place_foreground_block"
}
-
}
return
}
- val slabPart = if ((gameWorld.hasForeAt(x, y - 1)
- || gameWorld.getForeMap(x - 1, y) == placeable.topPartBlock
- || gameWorld.getForeMap(x + 1, y) == placeable.topPartBlock)
- && !gameWorld.hasForeAt(x, y + 1)) {
+ val slabPart = if ((
+ gameWorld.hasForeAt(x, y - 1) ||
+ gameWorld.getForeMap(x - 1, y) == placeable.topPartBlock ||
+ gameWorld.getForeMap(x + 1, y) == placeable.topPartBlock
+ ) &&
+ !gameWorld.hasForeAt(x, y + 1)
+ ) {
placeable.topPartBlock
} else {
placeable.bottomPartBlock
private const val TAG = "PlaceSlabAction"
const val ACTION_KEY = "place_slab"
}
-}
\ No newline at end of file
+}
interface IUseBlockAction {
fun perform(block: Block, x: Int, y: Int)
-
-}
\ No newline at end of file
+}
override fun perform(block: Block, x: Int, y: Int) {
// TODO: transform x
val chest = (containerController.getContainer(x, y, Layer.FOREGROUND.z) as? Chest)
- ?: (containerController.getContainer(x, y, Layer.BACKGROUND.z) as? Chest)
+ ?: (containerController.getContainer(x, y, Layer.BACKGROUND.z) as? Chest)
?: return
gameWindowsManager.openChest(chest)
}
companion object {
const val KEY = "chest"
}
-}
\ No newline at end of file
+}
@GameScope
@BindUseBlockAction(stringKey = UseCraftingTableAction.KEY)
class UseCraftingTableAction @Inject constructor(
- private val gameWindowsManager: GameWindowsManager
+ private val gameWindowsManager: GameWindowsManager,
) : IUseBlockAction {
override fun perform(block: Block, x: Int, y: Int) {
companion object {
const val KEY = "crafting_table"
}
-}
\ No newline at end of file
+}
override fun perform(block: Block, x: Int, y: Int) {
// TODO: transform x
- val furnace = (containerController.getContainer(x, y, Layer.FOREGROUND.z)
- ?: containerController.getContainer(x, y, Layer.FOREGROUND.z)) as? Furnace
+ val furnace = (
+ containerController.getContainer(x, y, Layer.FOREGROUND.z)
+ ?: containerController.getContainer(x, y, Layer.FOREGROUND.z)
+ ) as? Furnace
furnace ?: return
gameWindowsManager.openFurnace(furnace)
companion object {
const val KEY = "furnace"
}
-}
\ No newline at end of file
+}
interface IUseItemAction {
fun perform(item: Item.Usable, x: Int, y: Int)
-
-}
\ No newline at end of file
+}
class UseBedAction @Inject constructor(
private val gameWorld: GameWorld,
private val mobController: MobController,
- private val getBlockByKeyUseCase: GetBlockByKeyUseCase
+ private val getBlockByKeyUseCase: GetBlockByKeyUseCase,
) : IUseItemAction {
override fun perform(item: Item.Usable, x: Int, y: Int) {
companion object {
const val ACTION_KEY = "use_water_bucket"
}
-
}
* This will not be called if [checkConditions] returned false
*/
fun handle(action: A)
-
-}
\ No newline at end of file
+}
val hotbar = requireNotNull(getTextureRegionByNameUseCase["hotbar"])
return this.screenY <= hotbar.regionHeight &&
- this.screenX >= this.cameraViewport.width / 2 - hotbar.regionWidth / 2 &&
- this.screenX <= this.cameraViewport.width / 2 + hotbar.regionWidth / 2
+ this.screenX >= this.cameraViewport.width / 2 - hotbar.regionWidth / 2 &&
+ this.screenX <= this.cameraViewport.width / 2 + hotbar.regionWidth / 2
}
fun isInsideWindow(action: MouseInputAction, windowTexture: TextureRegion): Boolean {
return action.screenY > action.cameraViewport.height / 2 - windowTexture.regionHeight / 2 &&
- action.screenY < action.cameraViewport.height / 2 + windowTexture.regionHeight / 2 &&
- action.screenX > action.cameraViewport.width / 2 - windowTexture.regionWidth / 2 &&
- action.screenX < action.cameraViewport.width / 2 + windowTexture.regionWidth / 2
+ action.screenY < action.cameraViewport.height / 2 + windowTexture.regionHeight / 2 &&
+ action.screenX > action.cameraViewport.width / 2 - windowTexture.regionWidth / 2 &&
+ action.screenX < action.cameraViewport.width / 2 + windowTexture.regionWidth / 2
}
package ru.fredboy.cavedroid.ux.controls.input.action
-interface IGameInputAction
\ No newline at end of file
+interface IGameInputAction
data class KeyboardInputAction(
val actionKey: KeyboardInputActionKey,
val isKeyDown: Boolean,
-) : IGameInputAction
\ No newline at end of file
+) : IGameInputAction
val screenX: Float,
val screenY: Float,
val actionKey: MouseInputActionKey,
- val cameraViewport: Rectangle
-) : IGameInputAction
\ No newline at end of file
+ val cameraViewport: Rectangle,
+) : IGameInputAction
data object ShowMap : KeyboardInputActionKey
data class SelectHotbarSlot(
- val slot: Int
+ val slot: Int,
) : KeyboardInputActionKey
-}
\ No newline at end of file
+}
}
data class Dragged(
- override val pointer: Int
+ override val pointer: Int,
) : Touch {
override val touchUp: Boolean
get() = throw IllegalAccessException("not applicable for mouse dragged action")
}
data class Left(
- override val touchUp: Boolean
+ override val touchUp: Boolean,
) : MouseInputActionKey
data class Right(
- override val touchUp: Boolean
+ override val touchUp: Boolean,
) : MouseInputActionKey
data class Middle(
- override val touchUp: Boolean
+ override val touchUp: Boolean,
) : MouseInputActionKey
data class Screen(
data class Scroll(
val amountX: Float,
- val amountY: Float
+ val amountY: Float,
) : MouseInputActionKey {
override val touchUp: Boolean
get() = throw IllegalAccessException("not applicable for mouse scroll action")
}
-
-}
\ No newline at end of file
+}
@BindsIntoSet(
interfaceClass = IKeyboardInputHandler::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "KeyboardInputHandlersModule"
+ moduleName = "KeyboardInputHandlersModule",
)
-annotation class BindKeyboardInputHandler
\ No newline at end of file
+annotation class BindKeyboardInputHandler
@BindsIntoSet(
interfaceClass = IMouseInputHandler::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "MouseInputHandlersModule"
+ moduleName = "MouseInputHandlersModule",
)
-annotation class BindMouseInputHandler
\ No newline at end of file
+annotation class BindMouseInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.OpenInventory &&
- !action.isKeyDown && gameWindowsManager.currentWindowType != GameWindowType.NONE
+ !action.isKeyDown && gameWindowsManager.currentWindowType != GameWindowType.NONE
}
override fun handle(action: KeyboardInputAction) {
val selectedItem = gameWindowsManager.currentWindow?.selectedItem
if (selectedItem != null) {
- for (i in 1 .. selectedItem.amount) {
+ for (i in 1..selectedItem.amount) {
dropController.addDrop(
/* x = */ mobController.player.x + (32f * mobController.player.direction.basis),
/* y = */ mobController.player.y,
- /* item = */ selectedItem
+ /* item = */ selectedItem,
)
}
gameWindowsManager.currentWindow?.selectedItem = null
}
gameWindowsManager.closeWindow()
}
-}
\ No newline at end of file
+}
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.DropItem &&
- action.isKeyDown && gameWindowsManager.currentWindowType == GameWindowType.NONE &&
- !mobController.player.activeItem.item.isNone()
+ action.isKeyDown && gameWindowsManager.currentWindowType == GameWindowType.NONE &&
+ !mobController.player.activeItem.item.isNone()
}
private fun createDrop(item: Item, playerX: Float, playerY: Float, amount: Int) {
/* x = */ playerX + ((DROP_DISTANCE - Drop.DROP_SIZE / 2) * mobController.player.direction.basis),
/* y = */ playerY,
/* item = */ item,
- /* count = */ amount
+ /* count = */ amount,
)
}
override fun handle(action: KeyboardInputAction) {
val player = mobController.player
val currentItem = player.activeItem
- val dropAmount = if (currentItem.item.isTool()) currentItem.amount else 1
+ val dropAmount = if (currentItem.item.isTool()) currentItem.amount else 1
createDrop(currentItem.item, player.x, player.y, dropAmount)
player.decreaseCurrentItemCount(dropAmount)
companion object {
const val DROP_DISTANCE = 20f
}
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Down &&
- mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ mobController.player.isFlyMode &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobController.player.velocity.y = 0f
}
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up &&
- !mobController.player.swim &&
- mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ !mobController.player.swim &&
+ mobController.player.isFlyMode &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobController.player.velocity.y = 0f
}
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
override fun checkConditions(action: KeyboardInputAction): Boolean {
val isTouch = applicationContextRepository.isTouch()
return action.actionKey is KeyboardInputActionKey.Left &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !isTouch) &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !isTouch)
+ (mobController.player.controlMode == Player.ControlMode.WALK || !isTouch) &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !isTouch)
}
override fun handle(action: KeyboardInputAction) {
mobController.player.velocity.x = 0f
}
}
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
@BindKeyboardInputHandler
class GoRightKeyboardInputHandler @Inject constructor(
private val applicationContextRepository: ApplicationContextRepository,
- private val mobController: MobController
+ private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Right &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobController.player.velocity.x = 0f
}
}
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up &&
- mobController.player.canJump && !mobController.player.isFlyMode &&
- action.isKeyDown &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ mobController.player.canJump && !mobController.player.isFlyMode &&
+ action.isKeyDown &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobController.player.jump()
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return applicationContextRepository.isTouch() &&
- mobsController.player.controlMode == Player.ControlMode.CURSOR && action.isKeyDown &&
- (action.actionKey is KeyboardInputActionKey.Left ||
- action.actionKey is KeyboardInputActionKey.Right ||
- action.actionKey is KeyboardInputActionKey.Up ||
- action.actionKey is KeyboardInputActionKey.Down)
+ mobsController.player.controlMode == Player.ControlMode.CURSOR && action.isKeyDown &&
+ (
+ action.actionKey is KeyboardInputActionKey.Left ||
+ action.actionKey is KeyboardInputActionKey.Right ||
+ action.actionKey is KeyboardInputActionKey.Up ||
+ action.actionKey is KeyboardInputActionKey.Down
+ )
}
override fun handle(action: KeyboardInputAction) {
mobsController.checkPlayerCursorBounds()
}
-}
\ No newline at end of file
+}
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.OpenInventory &&
- !action.isKeyDown && gameWindowsManager.currentWindowType == GameWindowType.NONE
+ !action.isKeyDown && gameWindowsManager.currentWindowType == GameWindowType.NONE
}
override fun handle(action: KeyboardInputAction) {
gameWindowsManager.openSurvivalInventory()
}
}
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.api.ApplicationController
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
import ru.fredboy.cavedroid.game.controller.container.ContainerController
import ru.fredboy.cavedroid.game.controller.drop.DropController
gameController.quitGame()
}
-}
\ No newline at end of file
+}
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.SelectHotbarSlot &&
- action.isKeyDown
+ action.isKeyDown
}
override fun handle(action: KeyboardInputAction) {
mobController.player.activeSlot = (action.actionKey as KeyboardInputActionKey.SelectHotbarSlot).slot
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up && !action.isKeyDown &&
- mobController.player.swim &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ mobController.player.swim &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobController.player.swim = false
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.world.GameWorld
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up && action.isKeyDown &&
- !mobController.player.swim &&
- !mobController.player.canJump &&
- checkSwim() && !mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ !mobController.player.swim &&
+ !mobController.player.canJump &&
+ checkSwim() && !mobController.player.isFlyMode &&
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobController.player.swim = true
}
-
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
- return action.actionKey is KeyboardInputActionKey.SwitchControlsMode && !action.isKeyDown
- && applicationContextRepository.isTouch()
+ return action.actionKey is KeyboardInputActionKey.SwitchControlsMode && !action.isKeyDown &&
+ applicationContextRepository.isTouch()
}
override fun handle(action: KeyboardInputAction) {
mobController.player.controlMode = Player.ControlMode.WALK
}
}
-
-}
\ No newline at end of file
+}
override fun handle(action: KeyboardInputAction) {
gameContextRepository.setShowInfo(!gameContextRepository.shouldShowInfo())
}
-}
\ No newline at end of file
+}
@GameScope
@BindKeyboardInputHandler
class ToggleGameModeKeyboardInputHandler @Inject constructor(
- private val mobController: MobController
+ private val mobController: MobController,
) : IKeyboardInputHandler {
-
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.SwitchGameMode && action.isKeyDown
}
mobController.player.gameMode = 1
}
}
-
-
-}
\ No newline at end of file
+}
override fun handle(action: KeyboardInputAction) {
gameContextRepository.setShowMap(!gameContextRepository.shouldShowMap())
}
-}
\ No newline at end of file
+}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
override fun checkConditions(action: KeyboardInputAction): Boolean {
return mobsController.player.gameMode == 1 && action.actionKey is KeyboardInputActionKey.Up &&
- !mobsController.player.swim &&
- !mobsController.player.isFlyMode && !mobsController.player.canJump && action.isKeyDown &&
- (mobsController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
+ !mobsController.player.swim &&
+ !mobsController.player.isFlyMode && !mobsController.player.canJump && action.isKeyDown &&
+ (mobsController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
mobsController.player.isFlyMode = true
mobsController.player.velocity.y = 0f
}
-
-}
\ No newline at end of file
+}
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == windowType &&
- isInsideWindow(action, windowTexture) &&
- (action.actionKey is MouseInputActionKey.Left ||
- action.actionKey is MouseInputActionKey.Right ||
- action.actionKey is MouseInputActionKey.Screen)
- && (action.actionKey.touchUp || action.actionKey is MouseInputActionKey.Screen)
+ isInsideWindow(action, windowTexture) &&
+ (
+ action.actionKey is MouseInputActionKey.Left ||
+ action.actionKey is MouseInputActionKey.Right ||
+ action.actionKey is MouseInputActionKey.Screen
+ ) &&
+ (action.actionKey.touchUp || action.actionKey is MouseInputActionKey.Screen)
}
protected fun updateCraftResult(window: AbstractInventoryWindowWithCraftGrid) {
action: MouseInputAction,
items: MutableList<InventoryItem>,
window: AbstractInventoryWindow,
- index: Int
+ index: Int,
) {
if (action.actionKey is MouseInputActionKey.Screen) {
if (!action.actionKey.touchUp) {
action: MouseInputAction,
items: MutableList<InventoryItem>,
window: AbstractInventoryWindow,
- index: Int
+ index: Int,
) {
val selectedItem = window.selectedItem
- if (!selectedItem.isNoneOrNull() && (selectedItem.item != items[index].item ||
- !selectedItem.canBeAdded(items[index].amount))) {
+ if (!selectedItem.isNoneOrNull() && (
+ selectedItem.item != items[index].item ||
+ !selectedItem.canBeAdded(items[index].amount)
+ )
+ ) {
return
}
if (window is AbstractInventoryWindowWithCraftGrid) {
reduceCraftItems(window)
}
-
}
-
-}
\ No newline at end of file
+}
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == GameWindowType.NONE &&
- !action.isInsideHotbar(textureRegions) &&
- action.actionKey is MouseInputActionKey.Left
-
+ !action.isInsideHotbar(textureRegions) &&
+ action.actionKey is MouseInputActionKey.Left
}
override fun handle(action: MouseInputAction) {
mobController.player.startHitting()
}
}
-}
\ No newline at end of file
+}
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType != GameWindowType.NONE &&
- (action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen) &&
- action.actionKey.touchUp &&
- !isInsideWindow(action, getCurrentWindowTexture())
+ (action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen) &&
+ action.actionKey.touchUp &&
+ !isInsideWindow(action, getCurrentWindowTexture())
}
private fun getCurrentWindowTexture(): TextureRegion {
override fun handle(action: MouseInputAction) {
val selectedItem = gameWindowsManager.currentWindow?.selectedItem
if (selectedItem != null) {
- dropController.addDrop(
- /* x = */ mobController.player.x + (32f * mobController.player.direction.basis),
- /* y = */ mobController.player.y,
- /* item = */ selectedItem.item,
- /* count = */ selectedItem.amount,
- )
+ dropController.addDrop(
+ /* x = */ mobController.player.x + (32f * mobController.player.direction.basis),
+ /* y = */ mobController.player.y,
+ /* item = */ selectedItem.item,
+ /* count = */ selectedItem.amount,
+ )
gameWindowsManager.currentWindow?.selectedItem = null
}
gameWindowsManager.closeWindow()
}
-
}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import ru.fredboy.cavedroid.game.window.GameWindowType
import ru.fredboy.cavedroid.game.window.GameWindowsManager
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == GameWindowType.CREATIVE_INVENTORY &&
- (gameWindowsManager.isDragging || isInsideWindow(action, creativeInventoryTexture)) &&
- (checkStartDragConditions(action) || checkEndDragConditions(action) ||
- checkDragConditions(action) || action.actionKey is MouseInputActionKey.Scroll)
-
+ (gameWindowsManager.isDragging || isInsideWindow(action, creativeInventoryTexture)) &&
+ (
+ checkStartDragConditions(action) || checkEndDragConditions(action) ||
+ checkDragConditions(action) || action.actionKey is MouseInputActionKey.Scroll
+ )
}
private fun checkStartDragConditions(action: MouseInputAction): Boolean {
return (action.actionKey is MouseInputActionKey.Screen) &&
- !action.actionKey.touchUp && !gameWindowsManager.isDragging
+ !action.actionKey.touchUp && !gameWindowsManager.isDragging
}
private fun checkEndDragConditions(action: MouseInputAction): Boolean {
return action.actionKey is MouseInputActionKey.Screen &&
- action.actionKey.touchUp && gameWindowsManager.isDragging
+ action.actionKey.touchUp && gameWindowsManager.isDragging
}
private fun checkDragConditions(action: MouseInputAction): Boolean {
return applicationContextRepository.isTouch() && action.actionKey is MouseInputActionKey.Dragged &&
- abs(action.screenY - dragStartY) >= DRAG_SENSITIVITY
+ abs(action.screenY - dragStartY) >= DRAG_SENSITIVITY
}
private fun clampScrollAmount() {
MathUtils.clamp(
/* value = */ gameWindowsManager.creativeScrollAmount,
/* min = */ 0,
- /* max = */ (gameWindowsManager.currentWindow as CreativeInventoryWindow).getMaxScroll(itemsRepository)
+ /* max = */ (gameWindowsManager.currentWindow as CreativeInventoryWindow).getMaxScroll(itemsRepository),
)
}
companion object {
private const val DRAG_SENSITIVITY = 16f
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.math.MathUtils
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.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
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
private fun getCreativeTooltip(action: MouseInputAction): String? {
val creativeTexture = creativeInventoryTexture
- val xOnGrid = (action.screenX - (action.cameraViewport.width / 2 - creativeTexture.regionWidth / 2 +
- GameWindowsConfigs.Creative.itemsGridMarginLeft)) /
- GameWindowsConfigs.Creative.itemsGridColWidth
- val yOnGrid = (action.screenY - (action.cameraViewport.height / 2 - creativeTexture.regionHeight / 2 +
- GameWindowsConfigs.Creative.itemsGridMarginTop)) /
- GameWindowsConfigs.Creative.itemsGridRowHeight
+ val xOnGrid = (
+ action.screenX - (
+ action.cameraViewport.width / 2 - creativeTexture.regionWidth / 2 +
+ GameWindowsConfigs.Creative.itemsGridMarginLeft
+ )
+ ) /
+ GameWindowsConfigs.Creative.itemsGridColWidth
+ val yOnGrid = (
+ action.screenY - (
+ action.cameraViewport.height / 2 - creativeTexture.regionHeight / 2 +
+ GameWindowsConfigs.Creative.itemsGridMarginTop
+ )
+ ) /
+ GameWindowsConfigs.Creative.itemsGridRowHeight
if (xOnGrid < 0 || xOnGrid >= GameWindowsConfigs.Creative.itemsInRow ||
- yOnGrid < 0 || yOnGrid >= GameWindowsConfigs.Creative.itemsInCol) {
+ yOnGrid < 0 || yOnGrid >= GameWindowsConfigs.Creative.itemsInCol
+ ) {
return null
}
- val itemIndex = (gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow +
- (xOnGrid.toInt() + yOnGrid.toInt() * GameWindowsConfigs.Creative.itemsInRow))
+ val itemIndex = (
+ gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow +
+ (xOnGrid.toInt() + yOnGrid.toInt() * GameWindowsConfigs.Creative.itemsInRow)
+ )
val item = getItemByIndexUseCase[itemIndex]
return item.params.name
tooltipManager.showMouseTooltip(getCreativeTooltip(action).orEmpty())
}
}
-
-}
\ No newline at end of file
+}
override fun checkConditions(action: MouseInputAction): Boolean {
return buttonHoldTask?.isScheduled == true ||
- ((action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen)
- && action.isInsideHotbar(textureRegions)
- || action.actionKey is MouseInputActionKey.Scroll) &&
- gameWindowsManager.currentWindowType == GameWindowType.NONE
+ (
+ (action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen) &&
+ action.isInsideHotbar(textureRegions) ||
+ action.actionKey is MouseInputActionKey.Scroll
+ ) &&
+ gameWindowsManager.currentWindowType == GameWindowType.NONE
}
private fun cancelHold() {
/* x = */ playerX + ((DROP_DISTANCE - Drop.DROP_SIZE / 2) * mobController.player.direction.basis),
/* y = */ playerY,
/* item = */ item,
- /* count = */ amount
+ /* count = */ amount,
)
}
private fun getActionSlot(action: MouseInputAction): Int {
- return ((action.screenX -
- (action.cameraViewport.width / 2 - hotbarTexture.regionWidth / 2))
- / HOTBAR_CELL_WIDTH).toInt()
+ return (
+ (
+ action.screenX -
+ (action.cameraViewport.width / 2 - hotbarTexture.regionWidth / 2)
+ ) /
+ HOTBAR_CELL_WIDTH
+ ).toInt()
}
private fun handleHold(action: MouseInputAction) {
private const val TOUCH_HOLD_TIME_SEC = 0.5f
private const val HOTBAR_CELL_WIDTH = 20
}
-
-}
\ No newline at end of file
+}
val yOnWindow = action.screenY - (action.cameraViewport.height / 2 - texture.regionHeight / 2)
val xOnGrid = (xOnWindow - GameWindowsConfigs.Chest.itemsGridMarginLeft) /
- GameWindowsConfigs.Chest.itemsGridColWidth
+ GameWindowsConfigs.Chest.itemsGridColWidth
val yOnGrid = (yOnWindow - GameWindowsConfigs.Chest.itemsGridMarginTop) /
- GameWindowsConfigs.Chest.itemsGridRowHeight
+ GameWindowsConfigs.Chest.itemsGridRowHeight
val xOnContent = (xOnWindow - GameWindowsConfigs.Chest.contentsMarginLeft) /
- GameWindowsConfigs.Chest.itemsGridColWidth
+ GameWindowsConfigs.Chest.itemsGridColWidth
val yOnContent = (yOnWindow - GameWindowsConfigs.Chest.contentsMarginTop) /
- GameWindowsConfigs.Chest.itemsGridRowHeight
+ GameWindowsConfigs.Chest.itemsGridRowHeight
val isInsideInventoryGrid = xOnGrid >= 0 && xOnGrid < GameWindowsConfigs.Chest.itemsInRow &&
- yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Chest.itemsInCol
+ yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Chest.itemsInCol
val isInsideContentGrid = xOnContent >= 0 && xOnContent < GameWindowsConfigs.Chest.contentsInRow &&
- yOnContent >= 0 && yOnContent < GameWindowsConfigs.Chest.contentsInCol
-
+ yOnContent >= 0 && yOnContent < GameWindowsConfigs.Chest.contentsInCol
if (isInsideInventoryGrid) {
handleInsideInventoryGrid(action, xOnGrid.toInt(), yOnGrid.toInt())
handleInsideContentGrid(action, xOnContent.toInt(), yOnContent.toInt())
}
}
-}
\ No newline at end of file
+}
val yOnWindow = action.screenY - (action.cameraViewport.height / 2 - texture.regionHeight / 2)
val xOnGrid = (xOnWindow - GameWindowsConfigs.Crafting.itemsGridMarginLeft) /
- GameWindowsConfigs.Crafting.itemsGridColWidth
+ GameWindowsConfigs.Crafting.itemsGridColWidth
val yOnGrid = (yOnWindow - GameWindowsConfigs.Crafting.itemsGridMarginTop) /
- GameWindowsConfigs.Crafting.itemsGridRowHeight
+ GameWindowsConfigs.Crafting.itemsGridRowHeight
val xOnCraft = (xOnWindow - GameWindowsConfigs.Crafting.craftOffsetX) /
- GameWindowsConfigs.Crafting.itemsGridColWidth
+ GameWindowsConfigs.Crafting.itemsGridColWidth
val yOnCraft = (yOnWindow - GameWindowsConfigs.Crafting.craftOffsetY) /
- GameWindowsConfigs.Crafting.itemsGridRowHeight
+ GameWindowsConfigs.Crafting.itemsGridRowHeight
val isInsideInventoryGrid = xOnGrid >= 0 && xOnGrid < GameWindowsConfigs.Crafting.itemsInRow &&
- yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Crafting.itemsInCol
+ yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Crafting.itemsInCol
val isInsideCraftGrid = xOnCraft >= 0 && xOnCraft < GameWindowsConfigs.Crafting.craftGridSize &&
- yOnCraft >= 0 && yOnCraft < GameWindowsConfigs.Crafting.craftGridSize
+ yOnCraft >= 0 && yOnCraft < GameWindowsConfigs.Crafting.craftGridSize
val isInsideCraftResult = xOnWindow > GameWindowsConfigs.Crafting.craftResultOffsetX &&
- xOnWindow < GameWindowsConfigs.Crafting.craftResultOffsetX + GameWindowsConfigs.Crafting.itemsGridColWidth &&
- yOnWindow > GameWindowsConfigs.Crafting.craftResultOffsetY &&
- yOnWindow < GameWindowsConfigs.Crafting.craftResultOffsetY + GameWindowsConfigs.Crafting.itemsGridRowHeight
+ xOnWindow < GameWindowsConfigs.Crafting.craftResultOffsetX + GameWindowsConfigs.Crafting.itemsGridColWidth &&
+ yOnWindow > GameWindowsConfigs.Crafting.craftResultOffsetY &&
+ yOnWindow < GameWindowsConfigs.Crafting.craftResultOffsetY + GameWindowsConfigs.Crafting.itemsGridRowHeight
if (isInsideInventoryGrid) {
handleInsideInventoryGrid(action, xOnGrid.toInt(), yOnGrid.toInt())
} else if (isInsideCraftResult) {
handleInsideCraftResult(action)
}
-
}
-}
\ No newline at end of file
+}
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == GameWindowType.CREATIVE_INVENTORY &&
- !gameWindowsManager.isDragging &&
- (action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen) &&
- action.actionKey.touchUp && isInsideWindow(action, creativeInventoryTexture)
+ !gameWindowsManager.isDragging &&
+ (action.actionKey is MouseInputActionKey.Left || action.actionKey is MouseInputActionKey.Screen) &&
+ action.actionKey.touchUp && isInsideWindow(action, creativeInventoryTexture)
}
override fun handle(action: MouseInputAction) {
val creativeTexture = creativeInventoryTexture
- val xOnGrid = (action.screenX - (action.cameraViewport.width / 2 - creativeTexture.regionWidth / 2 +
- GameWindowsConfigs.Creative.itemsGridMarginLeft)) /
- GameWindowsConfigs.Creative.itemsGridColWidth
- val yOnGrid = (action.screenY - (action.cameraViewport.height / 2 - creativeTexture.regionHeight / 2 +
- GameWindowsConfigs.Creative.itemsGridMarginTop)) /
- GameWindowsConfigs.Creative.itemsGridRowHeight
+ val xOnGrid = (
+ action.screenX - (
+ action.cameraViewport.width / 2 - creativeTexture.regionWidth / 2 +
+ GameWindowsConfigs.Creative.itemsGridMarginLeft
+ )
+ ) /
+ GameWindowsConfigs.Creative.itemsGridColWidth
+ val yOnGrid = (
+ action.screenY - (
+ action.cameraViewport.height / 2 - creativeTexture.regionHeight / 2 +
+ GameWindowsConfigs.Creative.itemsGridMarginTop
+ )
+ ) /
+ GameWindowsConfigs.Creative.itemsGridRowHeight
if (xOnGrid < 0 || xOnGrid >= GameWindowsConfigs.Creative.itemsInRow ||
- yOnGrid < 0 || yOnGrid >= GameWindowsConfigs.Creative.itemsInCol) {
+ yOnGrid < 0 || yOnGrid >= GameWindowsConfigs.Creative.itemsInCol
+ ) {
return
}
- val itemIndex = (gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow +
- (xOnGrid.toInt() + yOnGrid.toInt() * GameWindowsConfigs.Creative.itemsInRow))
+ val itemIndex = (
+ gameWindowsManager.creativeScrollAmount * GameWindowsConfigs.Creative.itemsInRow +
+ (xOnGrid.toInt() + yOnGrid.toInt() * GameWindowsConfigs.Creative.itemsInRow)
+ )
val item = getItemByIndexUseCase[itemIndex]
mobController.player.inventory.addItem(item)
}
-
-}
\ No newline at end of file
+}
private val gameWindowsManager: GameWindowsManager,
private val mobController: MobController,
private val textureRegions: GetTextureRegionByNameUseCase,
- itemsRepository: ItemsRepository
+ itemsRepository: ItemsRepository,
) : AbstractInventoryItemsMouseInputHandler(itemsRepository, gameWindowsManager, GameWindowType.FURNACE) {
override val windowTexture get() = requireNotNull(textureRegions["furnace"])
val yOnWindow = action.screenY - (action.cameraViewport.height / 2 - texture.regionHeight / 2)
val xOnGrid = (xOnWindow - GameWindowsConfigs.Furnace.itemsGridMarginLeft) /
- GameWindowsConfigs.Furnace.itemsGridColWidth
+ GameWindowsConfigs.Furnace.itemsGridColWidth
val yOnGrid = (yOnWindow - GameWindowsConfigs.Furnace.itemsGridMarginTop) /
- GameWindowsConfigs.Furnace.itemsGridRowHeight
+ GameWindowsConfigs.Furnace.itemsGridRowHeight
val isInsideInput = xOnWindow > GameWindowsConfigs.Furnace.smeltInputMarginLeft &&
- xOnWindow < GameWindowsConfigs.Furnace.smeltInputMarginLeft + GameWindowsConfigs.Furnace.itemsGridColWidth &&
- yOnWindow > GameWindowsConfigs.Furnace.smeltInputMarginTop &&
- yOnWindow < GameWindowsConfigs.Furnace.smeltInputMarginTop + GameWindowsConfigs.Furnace.itemsGridRowHeight
+ xOnWindow < GameWindowsConfigs.Furnace.smeltInputMarginLeft + GameWindowsConfigs.Furnace.itemsGridColWidth &&
+ yOnWindow > GameWindowsConfigs.Furnace.smeltInputMarginTop &&
+ yOnWindow < GameWindowsConfigs.Furnace.smeltInputMarginTop + GameWindowsConfigs.Furnace.itemsGridRowHeight
val isInsideFuel = xOnWindow > GameWindowsConfigs.Furnace.smeltFuelMarginLeft &&
- xOnWindow < GameWindowsConfigs.Furnace.smeltFuelMarginLeft + GameWindowsConfigs.Furnace.itemsGridColWidth &&
- yOnWindow > GameWindowsConfigs.Furnace.smeltFuelMarginTop &&
- yOnWindow < GameWindowsConfigs.Furnace.smeltFuelMarginTop + GameWindowsConfigs.Furnace.itemsGridRowHeight
+ xOnWindow < GameWindowsConfigs.Furnace.smeltFuelMarginLeft + GameWindowsConfigs.Furnace.itemsGridColWidth &&
+ yOnWindow > GameWindowsConfigs.Furnace.smeltFuelMarginTop &&
+ yOnWindow < GameWindowsConfigs.Furnace.smeltFuelMarginTop + GameWindowsConfigs.Furnace.itemsGridRowHeight
val isInsideResult = xOnWindow > GameWindowsConfigs.Furnace.smeltResultOffsetX &&
- xOnWindow < GameWindowsConfigs.Furnace.smeltResultOffsetX + GameWindowsConfigs.Furnace.itemsGridColWidth &&
- yOnWindow > GameWindowsConfigs.Furnace.smeltResultOffsetY &&
- yOnWindow < GameWindowsConfigs.Furnace.smeltResultOffsetY + GameWindowsConfigs.Furnace.itemsGridRowHeight
+ xOnWindow < GameWindowsConfigs.Furnace.smeltResultOffsetX + GameWindowsConfigs.Furnace.itemsGridColWidth &&
+ yOnWindow > GameWindowsConfigs.Furnace.smeltResultOffsetY &&
+ yOnWindow < GameWindowsConfigs.Furnace.smeltResultOffsetY + GameWindowsConfigs.Furnace.itemsGridRowHeight
val isInsideInventoryGrid = xOnGrid >= 0 && xOnGrid < GameWindowsConfigs.Furnace.itemsInRow &&
- yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Furnace.itemsInCol
+ yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Furnace.itemsInCol
if (isInsideInventoryGrid) {
handleInsideInventoryGrid(action, xOnGrid.toInt(), yOnGrid.toInt())
} else if (isInsideResult) {
handleInsideResult(action)
}
-
}
-}
\ No newline at end of file
+}
val yOnWindow = action.screenY - (action.cameraViewport.height / 2 - windowTexture.regionHeight / 2)
val xOnGrid = (xOnWindow - GameWindowsConfigs.Survival.itemsGridMarginLeft) /
- GameWindowsConfigs.Survival.itemsGridColWidth
+ GameWindowsConfigs.Survival.itemsGridColWidth
val yOnGrid = (yOnWindow - GameWindowsConfigs.Survival.itemsGridMarginTop) /
- GameWindowsConfigs.Survival.itemsGridRowHeight
+ GameWindowsConfigs.Survival.itemsGridRowHeight
val xOnCraft = (xOnWindow - GameWindowsConfigs.Survival.craftOffsetX) /
- GameWindowsConfigs.Survival.itemsGridColWidth
+ GameWindowsConfigs.Survival.itemsGridColWidth
val yOnCraft = (yOnWindow - GameWindowsConfigs.Survival.craftOffsetY) /
- GameWindowsConfigs.Survival.itemsGridRowHeight
+ GameWindowsConfigs.Survival.itemsGridRowHeight
val isInsideInventoryGrid = xOnGrid >= 0 && xOnGrid < GameWindowsConfigs.Survival.itemsInRow &&
- yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Survival.itemsInCol
+ yOnGrid >= 0 && yOnGrid < GameWindowsConfigs.Survival.itemsInCol
val isInsideCraftGrid = xOnCraft >= 0 && xOnCraft < GameWindowsConfigs.Survival.craftGridSize &&
- yOnCraft >= 0 && yOnCraft < GameWindowsConfigs.Survival.craftGridSize
+ yOnCraft >= 0 && yOnCraft < GameWindowsConfigs.Survival.craftGridSize
val isInsideCraftResult = xOnWindow > GameWindowsConfigs.Survival.craftResultOffsetX &&
- xOnWindow < GameWindowsConfigs.Survival.craftResultOffsetX + GameWindowsConfigs.Survival.itemsGridColWidth &&
- yOnWindow > GameWindowsConfigs.Survival.craftResultOffsetY &&
- yOnWindow < GameWindowsConfigs.Survival.craftResultOffsetY + GameWindowsConfigs.Survival.itemsGridRowHeight
+ xOnWindow < GameWindowsConfigs.Survival.craftResultOffsetX + GameWindowsConfigs.Survival.itemsGridColWidth &&
+ yOnWindow > GameWindowsConfigs.Survival.craftResultOffsetY &&
+ yOnWindow < GameWindowsConfigs.Survival.craftResultOffsetY + GameWindowsConfigs.Survival.itemsGridRowHeight
if (isInsideInventoryGrid) {
handleInsideInventoryGrid(action, xOnGrid.toInt(), yOnGrid.toInt())
} else if (isInsideCraftResult) {
handleInsideCraftResult(action)
}
-
}
-}
\ No newline at end of file
+}
override fun checkConditions(action: MouseInputAction): Boolean {
return buttonHoldTask?.isScheduled == true ||
- !action.isInsideHotbar(textureRegions) &&
- gameWindowsManager.currentWindowType == GameWindowType.NONE &&
- action.actionKey is MouseInputActionKey.Right
+ !action.isInsideHotbar(textureRegions) &&
+ gameWindowsManager.currentWindowType == GameWindowType.NONE &&
+ action.actionKey is MouseInputActionKey.Right
}
private fun cancelHold() {
placeBlockActionMap.placeToBackgroundAction(
item = item,
x = player.cursorX,
- y = player.cursorY
+ y = player.cursorY,
)
}
}
override fun run() {
handleHold()
}
-
}
Timer.schedule(buttonHoldTask, TOUCH_HOLD_TIME_SEC)
}
useBlockActionMap[block.params.key]?.perform(
block = block,
x = mobController.player.cursorX,
- y = mobController.player.cursorY
+ y = mobController.player.cursorY,
)
}
placeBlockActionMap.placeToForegroundAction(
item = item,
x = player.cursorX,
- y = player.cursorY
+ y = player.cursorY,
)
} else if (item is Item.Usable) {
useItemActionMap[item.useActionKey]?.perform(item, player.cursorX, player.cursorY)
- ?: Gdx.app.error(TAG, "use item action ${item.useActionKey} not found");
+ ?: Gdx.app.error(TAG, "use item action ${item.useActionKey} not found")
} else if (item is Item.Food && player.health < player.maxHealth) {
player.heal(item.heal)
player.decreaseCurrentItemCount()
private const val TAG = "UseItemMouseInputActionHandler"
private const val TOUCH_HOLD_TIME_SEC = 0.5f
}
-}
\ No newline at end of file
+}
if (!value) {
resetVelocity()
if (TimeUtils.timeSinceMillis(activateTimeMs) < 200L &&
- mobController.player.controlMode != Player.ControlMode.CURSOR && mobController.player.canJump) {
+ mobController.player.controlMode != Player.ControlMode.CURSOR && mobController.player.canJump
+ ) {
mobController.player.jump()
}
} else {
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == GameWindowType.NONE &&
- applicationContextRepository.isTouch() && action.actionKey is MouseInputActionKey.Touch && (action.actionKey.pointer == gameContextRepository.getJoystick().pointer || !active) && ((action.actionKey is MouseInputActionKey.Dragged) ||
- (action.screenX < action.cameraViewport.width / 2 && !action.actionKey.touchUp || active)) && !(action.actionKey is MouseInputActionKey.Screen && action.isInsideHotbar(textureRegions))
-
+ applicationContextRepository.isTouch() && action.actionKey is MouseInputActionKey.Touch && (action.actionKey.pointer == gameContextRepository.getJoystick().pointer || !active) && (
+ (action.actionKey is MouseInputActionKey.Dragged) ||
+ (action.screenX < action.cameraViewport.width / 2 && !action.actionKey.touchUp || active)
+ ) && !(action.actionKey is MouseInputActionKey.Screen && action.isInsideHotbar(textureRegions))
}
private fun handleTouchDown(action: MouseInputAction) {
val joyVector = joystick.getVelocityVector()
if (mobController.player.isFlyMode) {
- joyVector.scl(2f);
+ joyVector.scl(2f)
}
mobController.player.velocity.x = joyVector.x
}
}
}
-
-}
\ No newline at end of file
+}
return actionKey?.let { KeyboardInputAction(it, isKeyDown) }
}
-
-}
\ No newline at end of file
+}
import com.badlogic.gdx.math.Rectangle
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.ux.controls.input.action.MouseInputAction
import ru.fredboy.cavedroid.ux.controls.input.action.keys.MouseInputActionKey
import javax.inject.Inject
private fun getScreenY(mouseY: Float): Float {
return mouseY * (applicationContextRepository.getHeight() / Gdx.graphics.height)
}
-
-}
\ No newline at end of file
+}
@BindsIntoMapStringKey(
interfaceClass = IUpdateBlockAction::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "UpdateBlockActionsModule"
+ moduleName = "UpdateBlockActionsModule",
)
-annotation class BindUpdateBlockAction(val stringKey: String)
\ No newline at end of file
+annotation class BindUpdateBlockAction(val stringKey: String)
interface IUpdateBlockAction {
fun update(x: Int, y: Int)
-
-}
\ No newline at end of file
+}
companion object {
const val BLOCK_KEY = "bed_l"
}
-}
\ No newline at end of file
+}
companion object {
const val BLOCK_KEY = "bed_r"
}
-}
\ No newline at end of file
+}
companion object {
const val BLOCK_KEY = "grass"
}
-}
\ No newline at end of file
+}
companion object {
const val ACTION_KEY = "requires_block"
}
-}
\ No newline at end of file
+}
companion object {
const val BLOCK_KEY = "grass_snowed"
}
-}
\ No newline at end of file
+}
val startX = getChunkStart()
for (y in gameWorld.height downTo 0) {
- for (x in startX ..< startX + CHUNK_WIDTH) {
+ for (x in startX..<startX + CHUNK_WIDTH) {
updateBlock(x, y)
}
}
const val WORLD_BLOCKS_LOGIC_UPDATE_INTERVAL_SEC = .1f
}
-
}
private val itemsRepository: ItemsRepository,
) : Timer.Task() {
- private var updateTick: Short = 0;
+ private var updateTick: Short = 0
private val fluidStatesMap = mutableMapOf<KClass<out Block.Fluid>, List<Block.Fluid>>()
val onRight = gameWorld.getForeMap(x + 1, y)
return !onTop.isFluid() &&
- (onLeft !is Block.Fluid || onLeft.state >= current.state) &&
- (onRight !is Block.Fluid || onRight.state >= current.state)
+ (onLeft !is Block.Fluid || onLeft.state >= current.state) &&
+ (onRight !is Block.Fluid || onRight.state >= current.state)
}
private fun drainFluid(x: Int, y: Int): Boolean {
private fun fluidCanFlowThere(fluid: Block.Fluid, targetBlock: Block): Boolean {
return targetBlock.isNone() ||
- (!targetBlock.params.hasCollision && !targetBlock.isFluid()) ||
- (fluid::class == targetBlock::class && fluid.state < (targetBlock as Block.Fluid).state)
+ (!targetBlock.params.hasCollision && !targetBlock.isFluid()) ||
+ (fluid::class == targetBlock::class && fluid.state < (targetBlock as Block.Fluid).state)
}
private fun flowFluidTo(currentFluid: Block.Fluid, x: Int, y: Int, nextStateFluid: Block.Fluid) {
val fluid = gameWorld.getForeMap(x, y) as Block.Fluid
val stateList = fluidStatesMap[fluid::class] ?: return
- if (fluid.state < stateList.lastIndex && gameWorld.getForeMap(x, y + 1).params.hasCollision) {
- val nextState = getNextStateBlock(fluid) ?: return
+ if (fluid.state < stateList.lastIndex && gameWorld.getForeMap(x, y + 1).params.hasCollision) {
+ val nextState = getNextStateBlock(fluid) ?: return
- flowFluidTo(fluid, x - 1, y, nextState)
- flowFluidTo(fluid, x + 1, y, nextState)
- } else {
- flowFluidTo(fluid, x, y + 1, stateList[1])
- }
+ flowFluidTo(fluid, x - 1, y, nextState)
+ flowFluidTo(fluid, x + 1, y, nextState)
+ } else {
+ flowFluidTo(fluid, x, y + 1, stateList[1])
+ }
}
fun updateFluids(x: Int, y: Int) {
val midScreen = mobController.player.x.bl
for (y in gameWorld.height - 1 downTo 0) {
- for (x in 0 ..< min(gameWorld.width / 2, 32)) {
+ for (x in 0..<min(gameWorld.width / 2, 32)) {
updateFluids(midScreen + x, y)
updateFluids(midScreen - x, y)
}
private inner class UpdateCommand(
val priority: Int,
- val command: Runnable
+ val command: Runnable,
) {
constructor(block: Block, x: Int, y: Int, priority: Int) :
- this(priority, Runnable { gameWorld.setForeMap(x, y, block) })
+ this(priority, Runnable { gameWorld.setForeMap(x, y, block) })
constructor(fluid: Block.Fluid, x: Int, y: Int) :
- this(fluid, x, y, ((5 - fluid.state) + 1) * (if (fluid.isLava()) 2 else 1))
+ this(fluid, x, y, ((5 - fluid.state) + 1) * (if (fluid.isLava()) 2 else 1))
fun exec() = command.run()
-
}
companion object {
const val FLUID_UPDATE_INTERVAL_SEC = 0.25f
}
-
-}
\ No newline at end of file
+}
}
}
}
-
-
}
companion object {
const val ENVIRONMENTAL_MOB_DAMAGE_INTERVAL_SEC = 0.5f
}
-
-}
\ No newline at end of file
+}
mobController: MobController,
containerController: ContainerController,
getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
- getBlockDamageSprite: GetBlockDamageSpriteUseCase
+ getBlockDamageSprite: GetBlockDamageSpriteUseCase,
) : BlocksRenderer(gameWorld, mobController, containerController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
companion object {
private const val RENDER_LAYER = 100000
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.MathUtils
import com.badlogic.gdx.math.Rectangle
+import ru.fredboy.cavedroid.common.utils.px
import ru.fredboy.cavedroid.domain.assets.usecase.GetBlockDamageFrameCountUseCase
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
get() = isNone() || params.isTransparent
private fun blockDamageSprite(index: Int): Sprite? {
- if (index !in 0..< getBlockDamageFrameCount()) {
+ if (index !in 0..<getBlockDamageFrameCount()) {
return null
}
return getBlockDamageSprite[index]
/* x = */ cursorX.px - viewport.x + block.params.spriteMargins.left,
/* y = */ cursorY.px - viewport.y + block.params.spriteMargins.top,
/* width = */ block.spriteWidth,
- /* height = */ block.spriteHeight
+ /* height = */ block.spriteHeight,
)
sprite.draw(spriteBatch)
}
shapeRenderer: ShapeRenderer,
viewport: Rectangle,
x: Int,
- y: Int
+ y: Int,
) {
val foregroundBlock = gameWorld.getForeMap(x, y)
val backgroundBlock = gameWorld.getBackMap(x, y)
/* x = */ drawX + marginLeft,
/* y = */ drawY + marginTop,
/* width = */ backgroundBlock.width,
- /* height = */ backgroundBlock.height
+ /* height = */ backgroundBlock.height,
)
}
}
companion object {
private const val MAX_BLOCK_DAMAGE_INDEX = 10
}
-
-}
\ No newline at end of file
+}
"Block: ${gameWorld.getForeMap(player.cursorX, player.cursorY).params.key}",
"Hand: ${player.activeItem.item.params.key}",
"Game mode: ${player.gameMode}",
- "Block damage: ${player.blockDamage}"
+ "Block damage: ${player.blockDamage}",
)
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
import ru.fredboy.cavedroid.common.di.GameScope
-import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.common.utils.bl
import ru.fredboy.cavedroid.common.utils.drawString
import ru.fredboy.cavedroid.common.utils.forEachBlockInArea
import ru.fredboy.cavedroid.common.utils.px
+import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.items.model.block.Block
import ru.fredboy.cavedroid.game.controller.mob.MobController
shapeRenderer: ShapeRenderer,
minimapX: Float,
minimapY: Float,
- minimapSize: Float
+ minimapSize: Float,
) {
val mapArea = Rectangle(
/* x = */ mobController.player.x - (minimapSize.px / 2),
/* y = */ mobController.player.y - (minimapSize.px / 2),
/* width = */ minimapSize.px,
- /* height = */ minimapSize.px
+ /* height = */ minimapSize.px,
)
spriteBatch.end()
/* x = */ minimapX + (x - mapArea.x.bl),
/* y = */ minimapY + (y - mapArea.y.bl),
/* width = */ 1f,
- /* height = */ 1f
+ /* height = */ 1f,
)
}
}
shapeRenderer = shapeRenderer,
minimapX = viewport.width - MinimapConfig.margin - MinimapConfig.size,
minimapY = MinimapConfig.margin,
- minimapSize = MinimapConfig.size
+ minimapSize = MinimapConfig.size,
)
}
-
}
companion object {
const val size = 64f
}
}
-}
\ No newline at end of file
+}
companion object {
private const val RENDER_LAYER = 100200
}
-
-}
\ No newline at end of file
+}
mobController: MobController,
containerController: ContainerController,
getBlockDamageFrameCount: GetBlockDamageFrameCountUseCase,
- getBlockDamageSprite: GetBlockDamageSpriteUseCase
+ getBlockDamageSprite: GetBlockDamageSpriteUseCase,
) : BlocksRenderer(gameWorld, mobController, containerController, getBlockDamageFrameCount, getBlockDamageSprite) {
override val renderLayer get() = RENDER_LAYER
companion object {
private const val RENDER_LAYER = 100400
}
-}
\ No newline at end of file
+}
val totalHearts = Player.MAX_HEALTH / 2
val wholeHearts = player.health / 2
- for (i in 0..< totalHearts) {
+ for (i in 0..<totalHearts) {
if (i < wholeHearts) {
spriteBatch.draw(wholeHeart, x + i * wholeHeart.regionWidth, y)
} else if (i == wholeHearts && player.health % 2 == 1) {
spriteBatch.draw(emptyHeart, x + i * wholeHeart.regionWidth, y)
}
}
-
-
-
-
}
- private fun drawHotbarItems(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, hotbarX: Float) {
+ private fun drawHotbarItems(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, hotbarX: Float) {
mobController.player.inventory.items.asSequence().take(HotbarConfig.hotbarCells)
.forEachIndexed { index, item ->
if (item.item.isNone()) {
shapeRenderer = shapeRenderer,
font = getFont(),
x = hotbarX + HotbarConfig.horizontalMargin +
- index * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
+ index * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
y = HotbarConfig.verticalMargin,
getStringWidth = getStringWidth::invoke,
getStringHeight = getStringHeight::invoke,
private fun drawHotbarSelector(spriteBatch: SpriteBatch, hotbarX: Float) {
spriteBatch.draw(
/* region = */ hotbarSelectorTexture,
- /* x = */ hotbarX - HotbarSelectorConfig.horizontalPadding
- + mobController.player.activeSlot * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
- /* y = */ -HotbarSelectorConfig.verticalPadding
+ /* x = */ hotbarX - HotbarSelectorConfig.horizontalPadding +
+ mobController.player.activeSlot * (HotbarConfig.itemSeparatorWidth + HotbarConfig.itemSlotSpace),
+ /* y = */ -HotbarSelectorConfig.verticalPadding,
)
}
font = getFont(),
str = tooltip,
x = viewport.width / 2 - getStringWidth(tooltip) / 2,
- y = hotbarTexture.regionHeight.toFloat()
+ y = hotbarTexture.regionHeight.toFloat(),
)
}
}
const val verticalPadding = 1f
}
}
-}
\ No newline at end of file
+}
spriteBatch: SpriteBatch,
shapeRenderer: ShapeRenderer,
viewport: Rectangle,
- delta: Float
+ delta: Float,
)
-}
\ No newline at end of file
+}
override val renderLayer get() = RENDER_LAYER
private fun drawMob(spriteBatch: SpriteBatch, viewport: Rectangle, mob: Mob, delta: Float) {
- mob.cycledInsideWorld(viewport, gameWorld.width.px)?.let { mobRect ->
- mob.draw(spriteBatch, mobRect.x - viewport.x, mobRect.y - viewport.y, delta)
- }
+ mob.cycledInsideWorld(viewport, gameWorld.width.px)?.let { mobRect ->
+ mob.draw(spriteBatch, mobRect.x - viewport.x, mobRect.y - viewport.y, delta)
+ }
}
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
/* spriteBatch = */ spriteBatch,
/* x = */ player.x - viewport.x - player.width / 2,
/* y = */ player.y - viewport.y,
- /* delta = */ delta
+ /* delta = */ delta,
)
mobController.mobs.forEach { mob ->
companion object {
private const val RENDER_LAYER = 100100
}
-}
\ No newline at end of file
+}
x = joystick.centerX - Joystick.RADIUS,
y = joystick.centerY - Joystick.RADIUS,
width = Joystick.SIZE,
- height = Joystick.SIZE
+ height = Joystick.SIZE,
)
spriteBatch.drawSprite(
x = joystick.activeX - Joystick.STICK_SIZE / 2,
y = joystick.activeY - Joystick.STICK_SIZE / 2,
width = Joystick.STICK_SIZE,
- height = Joystick.STICK_SIZE
+ height = Joystick.STICK_SIZE,
)
}
/* x = */ touchKey.x,
/* y = */ touchKey.y,
/* width = */ touchKey.width,
- /* height = */ touchKey.height
+ /* height = */ touchKey.height,
)
}
private const val SHADE_KEY = "shade"
}
-
-}
\ No newline at end of file
+}
const val RENDER_LAYER = 100600
}
-}
\ No newline at end of file
+}
@BindsIntoSet(
interfaceClass = IGameRenderer::class,
modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
- moduleName = "RenderModule"
+ moduleName = "RenderModule",
)
-annotation class BindRenderer
\ No newline at end of file
+annotation class BindRenderer
x = itemX,
y = itemY,
getStringWidth = getStringWidth::invoke,
- getStringHeight = getStringHeight::invoke
+ getStringHeight = getStringHeight::invoke,
) ?: item?.let { spriteBatch.drawSprite(it.sprite, itemX, itemY) }
}
}
companion object {
protected const val _TAG = "AbstractWindowRenderer"
}
-
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
-import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
import ru.fredboy.cavedroid.game.window.GameWindowsConfigs
import ru.fredboy.cavedroid.game.window.GameWindowsManager
import ru.fredboy.cavedroid.game.window.inventory.ChestInventoryWindow
+import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
+import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import javax.inject.Inject
@GameScope
override val renderLayer get() = WindowsRenderer.Companion.RENDER_LAYER
private val chestWindowTexture get() = requireNotNull(textureRegions[CHEST_WINDOW_KEY])
-
-
+
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
val windowTexture = chestWindowTexture
val window = gameWindowsManager.currentWindow as ChestInventoryWindow
cellWidth = GameWindowsConfigs.Chest.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Chest.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
-
+
drawItemsGrid(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
cellWidth = GameWindowsConfigs.Chest.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Chest.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Chest.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Chest.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
window.selectedItem?.drawSelected(
companion object {
private const val CHEST_WINDOW_KEY = "chest"
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
-import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
import ru.fredboy.cavedroid.game.window.GameWindowsConfigs
import ru.fredboy.cavedroid.game.window.GameWindowsManager
import ru.fredboy.cavedroid.game.window.inventory.CraftingInventoryWindow
+import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
+import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import javax.inject.Inject
@GameScope
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Crafting.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Crafting.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
window.craftResult.draw(
companion object {
private const val CRAFTING_WINDOW_KEY = "crafting_table"
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
-import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
import ru.fredboy.cavedroid.game.window.GameWindowsConfigs
import ru.fredboy.cavedroid.game.window.GameWindowsManager
import ru.fredboy.cavedroid.game.window.inventory.CreativeInventoryWindow
+import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
+import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import javax.inject.Inject
import kotlin.math.min
private val creativeWindowTexture get() = requireNotNull(textureRegions[CREATIVE_WINDOW_KEY])
private val scrollIndicatorTexture get() = requireNotNull(textureRegions[SCROLL_INDICATOR_KEY])
-
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
val creativeWindow = creativeWindowTexture
val windowX = viewport.width / 2 - creativeWindow.regionWidth / 2
val windowY = viewport.height / 2 - creativeWindow.regionHeight / 2
val oneScrollAmount = GameWindowsConfigs.Creative.scrollIndicatorFullHeight /
- (gameWindowsManager.currentWindow as CreativeInventoryWindow).getMaxScroll(itemsRepository)
+ (gameWindowsManager.currentWindow as CreativeInventoryWindow).getMaxScroll(itemsRepository)
spriteBatch.draw(creativeWindow, windowX, windowY)
spriteBatch.draw(
/* region = */ scrollIndicatorTexture,
/* x = */ windowX + GameWindowsConfigs.Creative.scrollIndicatorMarginLeft,
- /* y = */ windowY + GameWindowsConfigs.Creative.scrollIndicatorMarginTop
- + (gameWindowsManager.creativeScrollAmount * oneScrollAmount)
+ /* y = */ windowY + GameWindowsConfigs.Creative.scrollIndicatorMarginTop +
+ (gameWindowsManager.creativeScrollAmount * oneScrollAmount),
)
val allItems = itemsRepository.getAllItems()
cellWidth = GameWindowsConfigs.Creative.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Creative.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Creative.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Creative.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
}
private const val CREATIVE_WINDOW_KEY = "creative"
private const val SCROLL_INDICATOR_KEY = "handle"
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.Rectangle
-import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
-import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.common.utils.drawSprite
import ru.fredboy.cavedroid.common.utils.withScissors
import ru.fredboy.cavedroid.game.window.GameWindowsConfigs
import ru.fredboy.cavedroid.game.window.GameWindowsManager
import ru.fredboy.cavedroid.game.window.inventory.FurnaceInventoryWindow
+import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
+import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import javax.inject.Inject
@GameScope
private val furnaceProgress by lazy { Sprite(textureRegions["furnace_progress"]) }
private val furnaceBurn by lazy { Sprite(textureRegions["furnace_burn"]) }
-
+
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
val windowTexture = furnaceWindowTexture
-
+
val window = gameWindowsManager.currentWindow as FurnaceInventoryWindow
val windowX = viewport.width / 2 - windowTexture.regionWidth / 2
cellWidth = GameWindowsConfigs.Furnace.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Furnace.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Furnace.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Furnace.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
window.furnace.fuel.draw(
spriteBatch.drawSprite(
sprite = furnaceBurn,
x = windowX + GameWindowsConfigs.Furnace.fuelBurnMarginLeft,
- y = windowY + GameWindowsConfigs.Furnace.fuelBurnMarginTop
+ y = windowY + GameWindowsConfigs.Furnace.fuelBurnMarginTop,
)
}
companion object {
private const val FURNACE_WINDOW_KEY = "furnace"
}
-}
\ No newline at end of file
+}
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.math.MathUtils
import com.badlogic.gdx.math.Rectangle
-import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
-import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringHeightUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetStringWidthUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.window.GameWindowsConfigs
import ru.fredboy.cavedroid.game.window.GameWindowsManager
import ru.fredboy.cavedroid.game.window.inventory.SurvivalInventoryWindow
+import ru.fredboy.cavedroid.ux.rendering.IGameRenderer
+import ru.fredboy.cavedroid.ux.rendering.WindowsRenderer
import javax.inject.Inject
import kotlin.math.atan
private fun drawPlayerPortrait(spriteBatch: SpriteBatch, windowX: Float, windowY: Float, delta: Float) {
val portraitX = windowX + GameWindowsConfigs.Survival.portraitMarginLeft +
- (GameWindowsConfigs.Survival.portraitWidth / 2 - mobController.player.width / 2)
+ (GameWindowsConfigs.Survival.portraitWidth / 2 - mobController.player.width / 2)
val portraitY = windowY + GameWindowsConfigs.Survival.portraitMarginTop +
- (GameWindowsConfigs.Survival.portraitHeight / 2 - mobController.player.height / 2)
+ (GameWindowsConfigs.Survival.portraitHeight / 2 - mobController.player.height / 2)
setPortraitHeadRotation(portraitX, portraitY)
mobController.player.draw(spriteBatch, portraitX, portraitY, delta)
cellWidth = GameWindowsConfigs.Survival.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Survival.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Survival.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Survival.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
drawItemsGrid(
cellWidth = GameWindowsConfigs.Survival.itemsGridColWidth,
cellHeight = GameWindowsConfigs.Survival.itemsGridRowHeight,
getStringWidth = getStringWidth,
- getStringHeight = getStringHeight
+ getStringHeight = getStringHeight,
)
window.craftResult.draw(
companion object {
private const val SURVIVAL_WINDOW_KEY = "survival"
}
-}
\ No newline at end of file
+}
}
if (isFullscreen) {
- Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode);
+ Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode)
} else {
Gdx.graphics.setWindowedMode(960, 540)
}
width = width,
height = height,
isFullscreen = isFullscreen,
- useDynamicCamera = preferencesStore.getPreference("dyncam").toBoolean()
- )
+ useDynamicCamera = preferencesStore.getPreference("dyncam").toBoolean(),
+ ),
)
.applicationController(this)
.preferencesStore(preferencesStore)
private const val TAG = "CaveDroidApplication"
private const val DEFAULT_VIEWPORT_WIDTH = 480f
}
-}
\ No newline at end of file
+}
companion object {
private const val SCALE = .5f
}
-}
\ No newline at end of file
+}
DataItemsModule::class,
DataSaveModule::class,
ApplicationContextModule::class,
- ]
+ ],
)
interface ApplicationComponent {
fun preferencesStore(impl: PreferencesStore): Builder
fun build(): ApplicationComponent
-
}
-}
\ No newline at end of file
+}
/* viewportWidth = */ applicationContextRepository.getWidth(),
/* viewportHeight = */ applicationContextRepository.getHeight(),
)
- }
- )
+ },
+ ),
)
}
}
override fun pause() {
-
}
override fun resume() {
-
}
override fun hide() {
-
}
override fun dispose() {
resetGameComponent()
}
-}
\ No newline at end of file
+}
import dagger.BindsInstance
import dagger.Component
-import ru.deadsoftware.cavedroid.generated.module.*
+import ru.deadsoftware.cavedroid.generated.module.KeyboardInputHandlersModule
+import ru.deadsoftware.cavedroid.generated.module.MouseInputHandlersModule
+import ru.deadsoftware.cavedroid.generated.module.PlaceBlockActionsModule
+import ru.deadsoftware.cavedroid.generated.module.RenderModule
+import ru.deadsoftware.cavedroid.generated.module.UpdateBlockActionsModule
+import ru.deadsoftware.cavedroid.generated.module.UseBlockActionsModule
+import ru.deadsoftware.cavedroid.generated.module.UseItemActionsModule
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.data.configuration.di.GameContextModule
import ru.fredboy.cavedroid.data.configuration.model.GameContext
ControllerDropModule::class,
GameContextModule::class,
MobControllerModule::class,
- ]
+ ],
)
interface GameComponent {
fun build(): GameComponent
}
-}
\ No newline at end of file
+}
initialBackMap = mapData?.retrieveBackMap(),
)
}
-}
\ No newline at end of file
+}
menuRenderer.dispose()
menuButtonRepository.dispose()
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "exit_game_action"
}
-}
\ No newline at end of file
+}
fun perform()
fun canPerform(): Boolean = true
-
-}
\ No newline at end of file
+}
companion object {
const val KEY = "load_game_action"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "new_game_creative_action"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "new_game_survival_action"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "menu_main_action"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "new_game_action"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "options_action"
}
-}
\ No newline at end of file
+}
DataMenuModule::class,
MenuBooleanOptionsModule::class,
MenuActionsModule::class,
- ]
+ ],
)
interface MenuComponent {
screenX: Int,
screenY: Int,
pointer: Int,
- button: Int
+ button: Int,
): Boolean {
val touchX = applicationContextRepository.getWidth() / Gdx.graphics.width * screenX.toFloat()
val touchY = applicationContextRepository.getHeight() / Gdx.graphics.height * screenY.toFloat()
/* x = */ applicationContextRepository.getWidth() / 2 - 100,
/* y = */ applicationContextRepository.getHeight() / 4 + index * 30,
/* width = */ 200f,
- /* height = */ 20f
+ /* height = */ 20f,
)
if (rect.contains(touchX, touchY)) {
}
}
}
-
}
}
screenX: Int,
screenY: Int,
pointer: Int,
- button: Int
+ button: Int,
): Boolean {
return false
}
screenX: Int,
screenY: Int,
pointer: Int,
- button: Int
+ button: Int,
): Boolean {
return false
}
companion object {
private const val TAG = "MenuInputProcessor"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "dyncam"
}
-}
\ No newline at end of file
+}
companion object {
const val KEY = "fullscreen"
}
-}
\ No newline at end of file
+}
fun getOption(): Boolean
fun toggleOption()
-
-}
\ No newline at end of file
+}
is MenuButton.Simple -> button.label
is MenuButton.BooleanOption -> String.format(
button.label,
- button.optionKeys.map { key -> buttonBooleanOptions[key]?.getOption().toString() }
+ button.optionKeys.map { key -> buttonBooleanOptions[key]?.getOption().toString() },
)
}
val backgroundRegionWidth = backgroundRegion.regionWidth
val backgroundRegionHeight = backgroundRegion.regionWidth
- for (x in 0 .. applicationContextRepository.getWidth().toInt() / backgroundRegionWidth) {
- for (y in 0 .. applicationContextRepository.getHeight().toInt() / backgroundRegionHeight) {
+ for (x in 0..applicationContextRepository.getWidth().toInt() / backgroundRegionWidth) {
+ for (y in 0..applicationContextRepository.getHeight().toInt() / backgroundRegionHeight) {
spriter.draw(
/* region = */ backgroundRegion,
/* x = */ x * backgroundRegionWidth.toFloat(),
str = "CaveDroid " + CaveDroidConstants.VERSION,
x = 0f,
y = applicationContextRepository.getHeight() - getStringHeight("CaveDroid " + CaveDroidConstants.VERSION) * 1.5f,
- );
+ )
spriter.end()
-
}
fun dispose() {
private const val KEY_BUTTON_ENABLED_TEXTURE = "button_1"
private const val KEY_BUTTON_DISABLED_TEXTURE = "button_0"
}
-
-}
\ No newline at end of file
+}
manifest {
attributes["Main-Class"] = desktopLauncherClassName
}
- from(files(configurations.runtimeClasspath.map { classpath ->
- classpath.map { file ->
- file.takeIf(File::isDirectory) ?: zipTree(file)
- }
- }))
+ from(
+ files(
+ configurations.runtimeClasspath.map { classpath ->
+ classpath.map { file ->
+ file.takeIf(File::isDirectory) ?: zipTree(file)
+ }
+ },
+ ),
+ )
with(tasks.jar.get())
}
with(config) {
setWindowIcon(
/* fileType = */ Files.FileType.Internal,
- /* ...filePaths = */ "icons/icon512.png", "icons/icon256.png", "icons/icon128.png"
+ "icons/icon512.png",
+ "icons/icon256.png",
+ "icons/icon128.png",
)
setTitle("CaveDroid")
setWindowedMode(960, 540)
Lwjgl3Application(caveGame, config)
}
-}
\ No newline at end of file
+}
override fun setPreference(key: String, value: String?) {
prefs.put(key, value)
}
-
-}
\ No newline at end of file
+}
