}
},
"options": {
+ "screen_scale": {
+ "type": "numerical_option",
+ "label": "Screen Scale: x%d",
+ "actionKey": "screen_scale_action",
+ "options": ["screen_scale"]
+ },
"dyncam": {
"type": "boolean_option",
"label": "Dynamic Camera: %s",
fun loadGame()
fun exitGame()
+
+ fun triggerResize()
}
internal var gameDirectory: String,
internal var width: Float,
internal var height: Float,
+ internal var screenScale: Int,
)
override fun getHeight(): Float = applicationContextStore.height
+ override fun getScreenScale(): Int = applicationContextStore.screenScale
+
override fun setTouch(isTouch: Boolean) {
applicationContextStore.isTouch = isTouch
}
override fun setHeight(height: Float) {
applicationContextStore.height = height
}
+
+ override fun setScreenScale(scale: Int) {
+ applicationContextStore.screenScale = scale
+ }
}
get() = synchronized(lock) { applicationContext.height }
set(value) = synchronized(lock) { applicationContext.height = value }
+ var screenScale: Int
+ get() = synchronized(lock) { applicationContext.screenScale }
+ set(value) = synchronized(lock) {
+ applicationContext.screenScale = value
+ preferencesStore.setPreference(KEY_SCREEN_SCALE_PREF, value.toString())
+ }
+
private companion object {
private const val KEY_FULLSCREEN_PREF = "fullscreen"
private const val KEY_DYNAMIC_CAMERA_PREF = "dyncam"
+ private const val KEY_SCREEN_SCALE_PREF = "screen_scale"
}
}
isEnabled = dto.enabled ?: true,
)
+ "numerical_option" -> MenuButton.NumericalOption(
+ label = dto.label.toString(),
+ isVisible = mapVisibility(dto.visibility),
+ actionKey = dto.actionKey.orEmpty(),
+ optionKeys = dto.options.orEmpty(),
+ isEnabled = dto.enabled ?: true,
+ )
+
"default", null -> MenuButton.Simple(
label = dto.label.toString(),
isVisible = mapVisibility(dto.visibility),
fun setButtonEnabled(button: MenuButton, isEnabled: Boolean): MenuButton = when (button) {
is MenuButton.Simple -> button.copy(isEnabled = isEnabled)
is MenuButton.BooleanOption -> button.copy(isEnabled = isEnabled)
+ is MenuButton.NumericalOption -> button.copy(isEnabled = isEnabled)
}
private fun mapVisibility(dto: MenuButtonVisibilityDto?): Boolean {
fun getHeight(): Float
+ fun getScreenScale(): Int
+
fun setTouch(isTouch: Boolean)
fun setFullscreen(fullscreen: Boolean)
fun setWidth(width: Float)
fun setHeight(height: Float)
+
+ fun setScreenScale(scale: Int)
}
override val isEnabled: Boolean,
) : MenuButton()
+ sealed class Option : MenuButton() {
+ abstract val optionKeys: List<String>
+ }
+
data class BooleanOption(
override val label: String,
override val isVisible: Boolean,
override val actionKey: String,
override val isEnabled: Boolean,
- val optionKeys: List<String>,
- ) : MenuButton()
+ override val optionKeys: List<String>,
+ ) : Option()
+
+ data class NumericalOption(
+ override val label: String,
+ override val isVisible: Boolean,
+ override val actionKey: String,
+ override val isEnabled: Boolean,
+ override val optionKeys: List<String>,
+ ) : Option()
}
height = height,
isFullscreen = isFullscreen,
useDynamicCamera = preferencesStore.getPreference("dyncam").toBoolean(),
+ screenScale = (preferencesStore.getPreference("screen_scale") ?: "1").toInt(),
),
)
.applicationController(this)
Gdx.app.exit()
}
+ override fun triggerResize() {
+ resize(Gdx.graphics.width, Gdx.graphics.height)
+ }
+
companion object {
private const val TAG = "CaveDroidApplication"
private const val DEFAULT_VIEWPORT_WIDTH = 480f
) : Screen {
override fun resize(width: Int, height: Int) {
- applicationContextRepository.setWidth(width.toFloat() * SCALE)
- applicationContextRepository.setHeight(height.toFloat() * SCALE)
- }
-
- companion object {
- private const val SCALE = .5f
+ applicationContextRepository.setWidth(width.toFloat() / applicationContextRepository.getScreenScale())
+ applicationContextRepository.setHeight(height.toFloat() / applicationContextRepository.getScreenScale())
}
}
import dagger.Component
import ru.deadsoftware.cavedroid.generated.module.MenuActionsModule
import ru.deadsoftware.cavedroid.generated.module.MenuBooleanOptionsModule
+import ru.deadsoftware.cavedroid.generated.module.MenuNumericalOptionsModule
import ru.fredboy.cavedroid.common.di.MenuScope
import ru.fredboy.cavedroid.data.menu.di.DataMenuModule
import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
DataMenuModule::class,
MenuBooleanOptionsModule::class,
MenuActionsModule::class,
+ MenuNumericalOptionsModule::class,
],
)
interface MenuComponent {
import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
import ru.fredboy.cavedroid.zygote.menu.action.IMenuAction
import ru.fredboy.cavedroid.zygote.menu.option.bool.IMenuBooleanOption
+import ru.fredboy.cavedroid.zygote.menu.option.numerical.IMenuNumericalOption
import javax.inject.Inject
@MenuScope
private val menuButtonRepository: MenuButtonRepository,
private val menuButtonActions: Map<String, @JvmSuppressWildcards IMenuAction>,
private val menuButtonBooleanOption: Map<String, @JvmSuppressWildcards IMenuBooleanOption>,
+ private val buttonNumericalOptions: Map<String, @JvmSuppressWildcards IMenuNumericalOption>,
) : InputProcessor {
override fun touchUp(
}
}
}
+
+ is MenuButton.NumericalOption -> {
+ menuButton.optionKeys.forEach { optionKey ->
+ buttonNumericalOptions[optionKey]?.setNextOption() ?: run {
+ Gdx.app.error(TAG, "Menu option handler for option '$optionKey' not found")
+ }
+ }
+ }
}
}
}
--- /dev/null
+package ru.fredboy.cavedroid.zygote.menu.option.annotation
+
+import ru.fredboy.automultibind.annotations.BindsIntoMapStringKey
+import ru.fredboy.cavedroid.common.automultibind.MultibindingConfig
+import ru.fredboy.cavedroid.zygote.menu.option.numerical.IMenuNumericalOption
+
+@BindsIntoMapStringKey(
+ interfaceClass = IMenuNumericalOption::class,
+ modulePackage = MultibindingConfig.GENERATED_MODULES_PACKAGE,
+ moduleName = "MenuNumericalOptionsModule",
+)
+annotation class BindsMenuNumericalOption(val stringKey: String)
--- /dev/null
+package ru.fredboy.cavedroid.zygote.menu.option.numerical
+
+interface IMenuNumericalOption {
+
+ fun getOption(): Number
+
+ fun setNextOption()
+}
--- /dev/null
+package ru.fredboy.cavedroid.zygote.menu.option.numerical
+
+import ru.fredboy.cavedroid.common.api.ApplicationController
+import ru.fredboy.cavedroid.common.di.MenuScope
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
+import ru.fredboy.cavedroid.zygote.menu.option.annotation.BindsMenuNumericalOption
+import javax.inject.Inject
+
+@MenuScope
+@BindsMenuNumericalOption(ScreenScaleMenuNumericalOption.KEY)
+class ScreenScaleMenuNumericalOption @Inject constructor(
+ private val applicationContextRepository: ApplicationContextRepository,
+ private val applicationController: ApplicationController,
+) : IMenuNumericalOption {
+
+ override fun getOption(): Number {
+ return applicationContextRepository.getScreenScale()
+ }
+
+ override fun setNextOption() {
+ val nextIndex = (SCALE_VALUES.indexOf(getOption()) + 1) % SCALE_VALUES.size
+ val nextValue = SCALE_VALUES[nextIndex]
+ applicationContextRepository.setScreenScale(nextValue)
+ applicationController.triggerResize()
+ }
+ companion object {
+ const val KEY = "screen_scale"
+ private val SCALE_VALUES = arrayOf(1, 2, 3, 4)
+ }
+}
import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
import ru.fredboy.cavedroid.zygote.menu.action.IMenuAction
import ru.fredboy.cavedroid.zygote.menu.option.bool.IMenuBooleanOption
+import ru.fredboy.cavedroid.zygote.menu.option.numerical.IMenuNumericalOption
import javax.inject.Inject
@MenuScope
private val getTextureRegionByName: GetTextureRegionByNameUseCase,
private val menuButtonActions: Map<String, @JvmSuppressWildcards IMenuAction>,
private val buttonBooleanOptions: Map<String, @JvmSuppressWildcards IMenuBooleanOption>,
+ private val buttonNumericalOptions: Map<String, @JvmSuppressWildcards IMenuNumericalOption>,
private val getFont: GetFontUseCase,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
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() }.toTypedArray(),
+ )
+ is MenuButton.NumericalOption -> String.format(
+ button.label,
+ *button.optionKeys.mapNotNull { key -> buttonNumericalOptions[key]?.getOption() }.toTypedArray(),
)
}
