class ApplicationContext(
internal val isDebug: Boolean,
internal var isTouch: Boolean,
+ internal var isFullscreen: Boolean,
+ internal var useDynamicCamera: Boolean,
internal var gameDirectory: String,
internal var width: Float,
internal var height: Float,
internal val isLoadGame: Boolean,
internal var showInfo: Boolean,
internal var showMap: Boolean,
- internal var isFullscreen: Boolean,
- internal var useDynamicCamera: Boolean,
internal var joystick: Joystick,
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
import javax.inject.Inject
override fun isTouch(): Boolean = applicationContextStore.isTouch
+ override fun isFullscreen(): Boolean = applicationContextStore.isFullscreen
+
+ override fun useDynamicCamera(): Boolean = applicationContextStore.useDynamicCamera
+
override fun getGameDirectory(): String = applicationContextStore.gameDirectory
override fun getWidth(): Float = applicationContextStore.width
applicationContextStore.isTouch = isTouch
}
+ override fun setFullscreen(fullscreen: Boolean) {
+ if (Gdx.app.type != Application.ApplicationType.Desktop) {
+ return
+ }
+
+ if (fullscreen) {
+ Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode);
+ } else {
+ Gdx.graphics.setWindowedMode(2 * getWidth().toInt(), 2 * getHeight().toInt())
+ }
+ applicationContextStore.isFullscreen = fullscreen
+ }
+
+ override fun setUseDynamicCamera(use: Boolean) {
+ applicationContextStore.useDynamicCamera = use
+ }
+
override fun setGameDirectory(path: String) {
applicationContextStore.gameDirectory = path
}
package ru.fredboy.cavedroid.data.configuration.repository
-import com.badlogic.gdx.Gdx
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.common.model.Joystick
import ru.fredboy.cavedroid.data.configuration.store.GameContextStore
import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import javax.inject.Inject
-import javax.inject.Singleton
@GameScope
class GameContextRepositoryImpl @Inject constructor(
override fun getJoystick(): Joystick = gameContextStore.joystick
- override fun isFullscreen(): Boolean = gameContextStore.isFullscreen
-
- override fun useDynamicCamera(): Boolean = gameContextStore.useDynamicCamera
-
override fun getCameraContext(): CameraContext = gameContextStore.cameraContext
override fun setShowInfo(show: Boolean) {
gameContextStore.joystick = joystick
}
- override fun setFullscreen(fullscreen: Boolean) {
- if (fullscreen) {
- Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode);
- } else {
- Gdx.graphics.setWindowedMode(
- /* width = */ getCameraContext().viewport.width.toInt(),
- /* height = */ getCameraContext().viewport.height.toInt(),
- );
- }
- gameContextStore.isFullscreen = fullscreen
- }
-
- override fun setUseDynamicCamera(use: Boolean) {
- gameContextStore.useDynamicCamera = use
- }
-
override fun setCameraContext(cameraContext: CameraContext) {
gameContextStore.cameraContext = cameraContext
}
package ru.fredboy.cavedroid.data.configuration.store
+import ru.fredboy.cavedroid.common.api.PreferencesStore
import ru.fredboy.cavedroid.data.configuration.model.ApplicationContext
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class ApplicationContextStore @Inject constructor(
private val applicationContext: ApplicationContext,
+ private val preferencesStore: PreferencesStore,
) {
private val lock = Any()
get() = synchronized(lock) { applicationContext.isTouch }
set(value) = synchronized(lock) { applicationContext.isTouch = value }
+ var isFullscreen: Boolean
+ get() = synchronized(lock) { applicationContext.isFullscreen }
+ set(value) = synchronized(lock) {
+ applicationContext.isFullscreen = value
+ preferencesStore.setPreference(KEY_FULLSCREEN_PREF, value.toString())
+ }
+
+ var useDynamicCamera: Boolean
+ get() = synchronized(lock) { applicationContext.useDynamicCamera }
+ set(value) = synchronized(lock) {
+ applicationContext.useDynamicCamera = value
+ preferencesStore.setPreference(KEY_DYNAMIC_CAMERA_PREF, value.toString())
+ }
+
var gameDirectory: String
get() = synchronized(lock) { applicationContext.gameDirectory }
set(value) = synchronized(lock) { applicationContext.gameDirectory = value }
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
get() = synchronized(lock) { gameContext.joystick }
set(value) = synchronized(lock) { gameContext.joystick = value }
- var isFullscreen: Boolean
- get() = synchronized(lock) { gameContext.isFullscreen }
- set(value) = synchronized(lock) { gameContext.isFullscreen = value }
-
- var useDynamicCamera: Boolean
- get() = synchronized(lock) { gameContext.useDynamicCamera }
- set(value) = synchronized(lock) { gameContext.useDynamicCamera = value }
-
var cameraContext: CameraContext
get() = synchronized(lock) { gameContext.cameraContext }
set(value) = synchronized(lock) { gameContext.cameraContext = value }
fun isTouch(): Boolean
+ fun isFullscreen(): Boolean
+
+ fun useDynamicCamera(): Boolean
+
+
fun getGameDirectory(): String
fun getWidth(): Float
fun setTouch(isTouch: Boolean)
+ fun setFullscreen(fullscreen: Boolean)
+
+ fun setUseDynamicCamera(use: Boolean)
+
fun setGameDirectory(path: String)
fun setWidth(width: Float)
fun getJoystick(): Joystick
- fun isFullscreen(): Boolean
-
- fun useDynamicCamera(): Boolean
-
fun getCameraContext(): CameraContext
fun setShowInfo(show: Boolean)
fun setJoystick(joystick: Joystick)
- fun setFullscreen(fullscreen: Boolean)
-
- fun setUseDynamicCamera(use: Boolean)
-
fun setCameraContext(cameraContext: CameraContext)
}
}
private void updateCameraPosition(float delta) {
- if (mGameContextRepository.useDynamicCamera()) {
+ if (mApplicationContextRepository.useDynamicCamera()) {
updateDynamicCameraPosition(delta);
} else {
updateStaticCameraPosition();
setScreen(applicationComponent.gameScreen.apply { newGame(gameMode) })
}
+ private fun initFullscreenMode(isFullscreen: Boolean) {
+ if (Gdx.app.type != Application.ApplicationType.Desktop) {
+ return
+ }
+
+ if (isFullscreen) {
+ Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode);
+ } else {
+ Gdx.graphics.setWindowedMode(960, 540)
+ }
+ }
+
override fun create() {
val width = DEFAULT_VIEWPORT_WIDTH
val height = width / Gdx.graphics.ratio
+ val isFullscreen = preferencesStore.getPreference("fullscreen").toBoolean()
+ initFullscreenMode(isFullscreen)
+
applicationComponent = DaggerApplicationComponent.builder()
.applicationContext(
ApplicationContext(
gameDirectory = gameDataDirectoryPath,
width = width,
height = height,
+ isFullscreen = isFullscreen,
+ useDynamicCamera = preferencesStore.getPreference("dyncam").toBoolean()
)
)
.applicationController(this)
isLoadGame = isLoadGame,
showInfo = false,
showMap = false,
- isFullscreen = false,
- useDynamicCamera = false,
joystick = Joystick(Player.SPEED),
cameraContext = CameraContext(
viewport = Rectangle(
}
override fun show() {
+ resetMenu()
Gdx.input.inputProcessor = menuInputProcessor
}
package ru.fredboy.cavedroid.zygote.menu.option.bool
import ru.fredboy.cavedroid.common.di.MenuScope
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
import ru.fredboy.cavedroid.zygote.menu.option.annotation.BindsMenuBooleanOption
import javax.inject.Inject
@MenuScope
@BindsMenuBooleanOption(DynamicCameraMenuBooleanOption.KEY)
class DynamicCameraMenuBooleanOption @Inject constructor(
-// private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
) : IMenuBooleanOption {
override fun getOption(): Boolean {
- return false
-// return gameContextRepository.useDynamicCamera()
+ return applicationContextRepository.useDynamicCamera()
}
override fun toggleOption() {
-// gameContextRepository.setUseDynamicCamera(!getOption())
+ applicationContextRepository.setUseDynamicCamera(!getOption())
}
companion object {
package ru.fredboy.cavedroid.zygote.menu.option.bool
import ru.fredboy.cavedroid.common.di.MenuScope
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
import ru.fredboy.cavedroid.zygote.menu.option.annotation.BindsMenuBooleanOption
import javax.inject.Inject
@MenuScope
@BindsMenuBooleanOption(FullscreenMenuBooleanOption.KEY)
class FullscreenMenuBooleanOption @Inject constructor(
-// private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
) : IMenuBooleanOption {
override fun getOption(): Boolean {
- return false
-// return gameContextRepository.isFullscreen()
+ return applicationContextRepository.isFullscreen()
}
override fun toggleOption() {
-// gameContextRepository.setFullscreen(!getOption())
+ applicationContextRepository.setFullscreen(!getOption())
}
companion object {
}
private fun getButtonTextureRegionKey(button: MenuButton): String {
- val buttonAction = menuButtonActions[button.actionKey]
-
- if (buttonAction?.canPerform() != true) {
+ if (button is MenuButton.Simple && menuButtonActions[button.actionKey]?.canPerform() != true) {
return KEY_BUTTON_DISABLED_TEXTURE
}
