dependencies {
useCommonModule()
- implementation((project(":core")))
+ useZygoteModule()
+
implementation(platform(Dependencies.Kotlin.bom))
implementation(Dependencies.LibGDX.gdx)
import android.os.Bundle
import com.badlogic.gdx.backends.android.AndroidApplication
import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration
+import ru.fredboy.cavedroid.zygote.CaveDroidApplication
class AndroidLauncher : AndroidApplication() {
config.useImmersiveMode = true
initialize(
- /* listener = */ CaveGame(
+ /* listener = */ CaveDroidApplication(
gameDataDirectoryPath = gameDataDirectoryPath,
isTouchScreen = true,
isDebug = BuildConfig.DEBUG,
+++ /dev/null
-plugins {
- id("java-library")
- id("org.jetbrains.kotlin.jvm")
- id("kotlin")
- id("idea")
- id("org.jetbrains.kotlin.plugin.serialization") version Versions.kotlin
- id ("com.google.devtools.ksp") version Versions.ksp
-}
-
-java.sourceCompatibility = ApplicationInfo.sourceCompatibility
-java.targetCompatibility = ApplicationInfo.sourceCompatibility
-
-sourceSets {
- buildDir = file("_build")
-}
-
-dependencies {
- useAutomultibind()
- useDagger()
- useLibgdx()
- useKotlinxSerializationJson()
- useKotlinxSerializationProtobuf()
-
- useCommonModule()
-
- useDataModules()
- useDomainModules()
- useEntityModules()
- useGameModules()
- useUxModules()
- useZygoteModule()
-
- implementation(Dependencies.jetbrainsAnnotations)
-}
package ru.fredboy.cavedroid.common.api
-interface GameController {
+interface ApplicationController {
fun quitGame()
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.di
+
+import dagger.Binds
+import dagger.Module
+import ru.fredboy.cavedroid.data.configuration.repository.ApplicationContextRepositoryImpl
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
+
+@Module
+abstract class ApplicationContextModule {
+
+ @Binds
+ internal abstract fun bindApplicationContextRepository(impl: ApplicationContextRepositoryImpl): ApplicationContextRepository
+}
\ No newline at end of file
import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
@Module
-abstract class DataConfigurationModule {
+abstract class GameContextModule {
@Binds
- internal abstract fun bindGameConfigurationRepository(impl: GameContextRepositoryImpl): GameContextRepository
-
+ internal abstract fun bindGameContextRepository(impl: GameContextRepositoryImpl): GameContextRepository
}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.model
+
+class ApplicationContext(
+ internal val isDebug: Boolean,
+ internal var isTouch: Boolean,
+ internal var gameDirectory: String,
+ internal var width: Float,
+ internal var height: Float,
+)
import ru.fredboy.cavedroid.common.model.Joystick
import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
-internal class GameContext {
-
- var isTouch: Boolean = false
-
- var gameDirectory: String = ""
-
- var width: Float = 0f
-
- var height: Float = 0f
-
- var showInfo: Boolean = false
-
- var showMap: Boolean = false
-
- var joystick: Joystick? = null
-
- var isFullscreen: Boolean = false
-
- var useDynamicCamera: Boolean = false
-
- var cameraContext: CameraContext? = null
-}
+class GameContext(
+ 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
+)
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.repository
+
+import ru.fredboy.cavedroid.data.configuration.store.ApplicationContextStore
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class ApplicationContextRepositoryImpl @Inject constructor(
+ private val applicationContextStore: ApplicationContextStore,
+) : ApplicationContextRepository {
+
+ override fun isDebug(): Boolean = applicationContextStore.isDebug
+
+ override fun isTouch(): Boolean = applicationContextStore.isTouch
+
+ override fun getGameDirectory(): String = applicationContextStore.gameDirectory
+
+ override fun getWidth(): Float = applicationContextStore.width
+
+ override fun getHeight(): Float = applicationContextStore.height
+
+ override fun setTouch(isTouch: Boolean) {
+ applicationContextStore.isTouch = isTouch
+ }
+
+ override fun setGameDirectory(path: String) {
+ applicationContextStore.gameDirectory = path
+ }
+
+ override fun setWidth(width: Float) {
+ applicationContextStore.width = width
+ }
+
+ override fun setHeight(height: Float) {
+ applicationContextStore.height = height
+ }
+}
\ No newline at end of file
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 javax.inject.Inject
import javax.inject.Singleton
-@Singleton
+@GameScope
class GameContextRepositoryImpl @Inject constructor(
private val gameContextStore: GameContextStore
) : GameContextRepository {
- override fun isTouch(): Boolean = gameContextStore.isTouch
-
- override fun getGameDirectory(): String = gameContextStore.gameDirectory
-
- override fun getWidth(): Float = gameContextStore.width
-
- override fun getHeight(): Float = gameContextStore.height
+ override fun isLoadGame(): Boolean = gameContextStore.isLoadGame
override fun shouldShowInfo(): Boolean = gameContextStore.showInfo
override fun shouldShowMap(): Boolean = gameContextStore.showMap
- override fun getJoystick(): Joystick? = gameContextStore.joystick
+ 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 setTouch(isTouch: Boolean) {
- gameContextStore.isTouch = isTouch
- }
-
- override fun setGameDirectory(path: String) {
- gameContextStore.gameDirectory = path
- }
-
- override fun setWidth(width: Float) {
- gameContextStore.width = width
- }
-
- override fun setHeight(height: Float) {
- gameContextStore.height = height
- }
+ override fun getCameraContext(): CameraContext = gameContextStore.cameraContext
override fun setShowInfo(show: Boolean) {
gameContextStore.showInfo = show
gameContextStore.showMap = show
}
- override fun setJoystick(joystick: Joystick?) {
+ override fun setJoystick(joystick: Joystick) {
gameContextStore.joystick = joystick
}
if (fullscreen) {
Gdx.graphics.setFullscreenMode(Gdx.graphics.displayMode);
} else {
- Gdx.graphics.setWindowedMode(getWidth().toInt(), getHeight().toInt());
+ Gdx.graphics.setWindowedMode(
+ /* width = */ getCameraContext().viewport.width.toInt(),
+ /* height = */ getCameraContext().viewport.height.toInt(),
+ );
}
gameContextStore.isFullscreen = fullscreen
}
gameContextStore.useDynamicCamera = use
}
- override fun setCameraContext(cameraContext: CameraContext?) {
+ override fun setCameraContext(cameraContext: CameraContext) {
gameContextStore.cameraContext = cameraContext
}
}
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.store
+
+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 lock = Any()
+
+ val isDebug: Boolean
+ get() = synchronized(lock) { applicationContext.isDebug }
+
+ var isTouch: Boolean
+ get() = synchronized(lock) { applicationContext.isTouch }
+ set(value) = synchronized(lock) { applicationContext.isTouch = value }
+
+ var gameDirectory: String
+ get() = synchronized(lock) { applicationContext.gameDirectory }
+ set(value) = synchronized(lock) { applicationContext.gameDirectory = value }
+
+ var width: Float
+ get() = synchronized(lock) { applicationContext.width }
+ set(value) = synchronized(lock) { applicationContext.width = value }
+
+ var height: Float
+ get() = synchronized(lock) { applicationContext.height }
+ set(value) = synchronized(lock) { applicationContext.height = value }
+
+}
\ No newline at end of file
package ru.fredboy.cavedroid.data.configuration.store
-import com.badlogic.gdx.graphics.OrthographicCamera
+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 javax.inject.Inject
-import javax.inject.Singleton
-@Singleton
-class GameContextStore @Inject constructor() {
+@GameScope
+class GameContextStore @Inject constructor(
+ private val gameContext: GameContext
+) {
private val lock = Any()
- private val gameContext = GameContext()
-
- var isTouch: Boolean
- get() = synchronized(lock) { gameContext.isTouch }
- set(value) = synchronized(lock) { gameContext.isTouch = value }
-
- var gameDirectory: String
- get() = synchronized(lock) { gameContext.gameDirectory }
- set(value) = synchronized(lock) { gameContext.gameDirectory = value }
-
- var width: Float
- get() = synchronized(lock) { gameContext.width }
- set(value) = synchronized(lock) { gameContext.width = value }
-
- var height: Float
- get() = synchronized(lock) { gameContext.height }
- set(value) = synchronized(lock) { gameContext.height = value }
+ val isLoadGame: Boolean
+ get() = gameContext.isLoadGame
var showInfo: Boolean
get() = synchronized(lock) { gameContext.showInfo }
get() = synchronized(lock) { gameContext.showMap }
set(value) = synchronized(lock) { gameContext.showMap = value }
- var joystick: Joystick?
+ var joystick: Joystick
get() = synchronized(lock) { gameContext.joystick }
set(value) = synchronized(lock) { gameContext.joystick = value }
get() = synchronized(lock) { gameContext.useDynamicCamera }
set(value) = synchronized(lock) { gameContext.useDynamicCamera = value }
- var cameraContext: CameraContext?
+ var cameraContext: CameraContext
get() = synchronized(lock) { gameContext.cameraContext }
set(value) = synchronized(lock) { gameContext.cameraContext = value }
--- /dev/null
+package ru.fredboy.cavedroid.domain.configuration.repository
+
+interface ApplicationContextRepository {
+
+ fun isDebug(): Boolean
+
+ fun isTouch(): Boolean
+
+ fun getGameDirectory(): String
+
+ fun getWidth(): Float
+
+ fun getHeight(): Float
+
+ fun setTouch(isTouch: Boolean)
+
+ fun setGameDirectory(path: String)
+
+ fun setWidth(width: Float)
+
+ fun setHeight(height: Float)
+
+}
\ No newline at end of file
interface GameContextRepository {
- fun isTouch(): Boolean
-
- fun getGameDirectory(): String
-
- fun getWidth(): Float
-
- fun getHeight(): Float
+ fun isLoadGame(): Boolean
fun shouldShowInfo(): Boolean
fun shouldShowMap(): Boolean
- fun getJoystick(): Joystick?
+ fun getJoystick(): Joystick
fun isFullscreen(): Boolean
fun useDynamicCamera(): Boolean
- fun getCameraContext(): CameraContext?
-
- fun setTouch(isTouch: Boolean)
-
- fun setGameDirectory(path: String)
-
- fun setWidth(width: Float)
-
- fun setHeight(height: Float)
+ fun getCameraContext(): CameraContext
fun setShowInfo(show: Boolean)
fun setShowMap(show: Boolean)
- fun setJoystick(joystick: Joystick?)
+ fun setJoystick(joystick: Joystick)
fun setFullscreen(fullscreen: Boolean)
fun setUseDynamicCamera(use: Boolean)
- fun setCameraContext(cameraContext: CameraContext?)
+ fun setCameraContext(cameraContext: CameraContext)
}
const val WIDTH = 4f
const val HEIGHT = 30f
- private const val SPEED = 69.072f
+ const val SPEED = 69.072f
private const val JUMP_VELOCITY = -133.332f
private val HIT_ANIMATION_RANGE = 30f..90f
+++ /dev/null
-package ru.deadsoftware.cavedroid;
-
-import org.jetbrains.annotations.Nullable;
-
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-@Singleton
-public class MainConfig {
-
- @Nullable
- private MainComponent mMainComponent;
-
- @Inject
- public MainConfig() {
- }
-
- public MainComponent getMainComponent() {
- assert mMainComponent != null;
- return mMainComponent;
- }
-
- public void setMainComponent(MainComponent mainComponent) {
- mMainComponent = mainComponent;
- }
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game;
-
-import dagger.Component;
-import ru.deadsoftware.cavedroid.MainComponent;
-import ru.deadsoftware.cavedroid.generated.module.*;
-import ru.fredboy.cavedroid.common.api.GameController;
-import ru.fredboy.cavedroid.common.di.GameScope;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
-import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository;
-import ru.fredboy.cavedroid.game.controller.container.di.ControllerContainerModule;
-import ru.fredboy.cavedroid.game.controller.drop.di.ControllerDropModule;
-import ru.fredboy.cavedroid.game.world.di.GameWorldModule;
-
-@GameScope
-@Component(dependencies = {
- MainComponent.class
- },
- modules = {GameModule.class,
- UseItemActionsModule.class,
- UpdateBlockActionsModule.class,
- PlaceBlockActionsModule.class,
- RenderModule.class,
- KeyboardInputHandlersModule.class,
- MouseInputHandlersModule.class,
- UseBlockActionsModule.class,
- GameWorldModule.class,
- ControllerContainerModule.class,
- ControllerDropModule.class
- })
-public interface GameComponent {
- GameProc getGameProc();
-
- ItemsRepository getItemsRepository();
-
- GameContextRepository getGameConfigurationRepository();
-
- GameController getGameController();
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game;
-
-import dagger.Module;
-import dagger.Provides;
-import ru.fredboy.cavedroid.common.di.GameScope;
-import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
-import ru.fredboy.cavedroid.domain.items.model.block.Block;
-import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository;
-import ru.fredboy.cavedroid.domain.items.usecase.GetFallbackItemUseCase;
-import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase;
-import ru.fredboy.cavedroid.domain.save.model.GameMapSaveData;
-import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository;
-import ru.fredboy.cavedroid.entity.container.abstraction.ContainerFactory;
-import ru.fredboy.cavedroid.entity.container.abstraction.ContainerWorldAdapter;
-import ru.fredboy.cavedroid.entity.drop.abstraction.DropAdapter;
-import ru.fredboy.cavedroid.entity.drop.abstraction.DropWorldAdapter;
-import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter;
-import ru.fredboy.cavedroid.game.controller.container.ContainerController;
-import ru.fredboy.cavedroid.game.controller.drop.DropController;
-import ru.fredboy.cavedroid.game.controller.mob.MobController;
-import ru.fredboy.cavedroid.game.world.GameWorld;
-
-@Module
-public class GameModule {
-
- private static boolean needLoad = false;
-
- public static void setNeedLoad(final boolean needLoad) {
- GameModule.needLoad = needLoad;
- }
-
- @Provides
- @GameScope
- public static DropController provideDropController(GameContextRepository gameContextRepository,
- SaveDataRepository saveDataRepository,
- ItemsRepository itemsRepository,
- DropWorldAdapter dropWorldAdapter) {
-
- DropController controller = needLoad
- ? saveDataRepository.loadDropController(gameContextRepository.getGameDirectory(), dropWorldAdapter)
- : new DropController(itemsRepository, dropWorldAdapter);
-
- return controller;
- }
-
- @Provides
- @GameScope
- public static ContainerController provideFurnaceController(GameContextRepository gameContextRepository,
- SaveDataRepository saveDataRepository,
- GetItemByKeyUseCase getItemByKeyUseCase,
- ContainerWorldAdapter containerWorldAdapter,
- ContainerFactory containerFactory,
- DropAdapter dropAdapter) {
- ContainerController controller = needLoad
- ? saveDataRepository.loadContainerController(gameContextRepository.getGameDirectory(), containerWorldAdapter, containerFactory, dropAdapter)
- : new ContainerController(getItemByKeyUseCase, containerWorldAdapter, containerFactory, dropAdapter);
-
- return controller;
- }
-
- @Provides
- @GameScope
- public static MobController provideMobsController(GameContextRepository gameContextRepository,
- SaveDataRepository saveDataRepository,
- MobAssetsRepository mobAssetsRepository,
- GetFallbackItemUseCase getFallbackItemUseCase,
- MobWorldAdapter mobWorldAdapter) {
-
- return needLoad
- ? saveDataRepository.loadMobController(gameContextRepository.getGameDirectory(), mobWorldAdapter)
- : new MobController(mobAssetsRepository, getFallbackItemUseCase, mobWorldAdapter);
- }
-
- @Provides
- @GameScope
- public static GameWorld provideGameWorld(GameContextRepository gameContextRepository,
- SaveDataRepository saveDataRepository,
- ItemsRepository itemsRepository) {
-
- final GameMapSaveData mapData = needLoad ? saveDataRepository.loadMap(gameContextRepository.getGameDirectory()) : null;
-
- Block[][] fm = mapData != null ? mapData.retrieveForeMap() : null;
- Block[][] bm = mapData != null ? mapData.retrieveBackMap() : null;
-
- return new GameWorld(itemsRepository, fm, bm);
- }
-
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.game;
-
-import com.badlogic.gdx.Screen;
-import org.jetbrains.annotations.Nullable;
-import ru.deadsoftware.cavedroid.MainConfig;
-
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-@Singleton
-public class GameScreen implements Screen {
-
- private final MainConfig mMainConfig;
-
- @Nullable
- private GameProc mGameProc;
-
- @Inject
- public GameScreen(MainConfig mainConfig) {
- mMainConfig = mainConfig;
- }
-
- public void newGame(int gameMode) {
- if (mGameProc != null) {
- mGameProc.dispose();
- }
-
- GameModule.setNeedLoad(false);
-
- GameComponent gameComponent = DaggerGameComponent.builder()
- .mainComponent(mMainConfig.getMainComponent()).build();
-
- mGameProc = gameComponent.getGameProc();
-
- mGameProc.setPlayerGameMode(gameMode);
- }
-
- public void loadGame() {
- if (mGameProc != null) {
- mGameProc.dispose();
- }
-
- GameModule.setNeedLoad(true);
-
- GameComponent gameComponent = DaggerGameComponent.builder()
- .mainComponent(mMainConfig.getMainComponent()).build();
-
- mGameProc = gameComponent.getGameProc();
- }
-
- @Override
- public void render(float delta) {
- mGameProc.update(delta);
- }
-
- @Override
- public void show() {
-// Gdx.input.setInputProcessor(mGameInputProcessor);
- mGameProc.show();
- }
-
- @Override
- public void resize(int width, int height) {
-
- }
-
- @Override
- public void pause() {
-
- }
-
- @Override
- public void resume() {
-
- }
-
- @Override
- public void hide() {
-
- }
-
- @Override
- public void dispose() {
- if (mGameProc != null) {
- mGameProc.dispose();
- }
- }
-
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.menu;
-
-import dagger.Component;
-import ru.deadsoftware.cavedroid.MainComponent;
-import ru.deadsoftware.cavedroid.generated.module.MenuActionsModule;
-import ru.fredboy.cavedroid.common.di.MenuScope;
-import ru.fredboy.cavedroid.data.menu.di.DataMenuModule;
-import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository;
-import ru.fredboy.cavedroid.game.controller.container.di.ControllerContainerModule;
-import ru.fredboy.cavedroid.game.controller.drop.di.ControllerDropModule;
-import ru.fredboy.cavedroid.zygote.menu.input.MenuInputProcessor;
-import ru.fredboy.cavedroid.zygote.menu.renderer.MenuRenderer;
-import ru.deadsoftware.cavedroid.generated.module.MenuBooleanOptionsModule;
-
-@MenuScope
-@Component(dependencies = MainComponent.class, modules = {ControllerContainerModule.class,
- ControllerDropModule.class, DataMenuModule.class, MenuBooleanOptionsModule.class, MenuActionsModule.class})
-public interface MenuComponent {
-
- public MenuRenderer menuRenderer();
-
- public MenuInputProcessor menuInputProcessor();
-
- public MenuButtonRepository menuButtonsRepository();
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid.menu;
-
-import com.badlogic.gdx.Gdx;
-import com.badlogic.gdx.Screen;
-import ru.deadsoftware.cavedroid.MainConfig;
-import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository;
-import ru.fredboy.cavedroid.zygote.menu.input.MenuInputProcessor;
-import ru.fredboy.cavedroid.zygote.menu.renderer.MenuRenderer;
-
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-@Singleton
-public class MenuScreen implements Screen {
-
- private final MenuRenderer mMenuRenderer;
-
- private final MenuInputProcessor mMenuInputProcessor;
-
- private final MenuButtonRepository mMenuButtonsRepository;
-
- @Inject
- public MenuScreen(MainConfig mainConfig) {
- MenuComponent menuComponent = DaggerMenuComponent.builder()
- .mainComponent(mainConfig.getMainComponent()).build();
-
- mMenuRenderer = menuComponent.menuRenderer();
- mMenuInputProcessor = menuComponent.menuInputProcessor();
- mMenuButtonsRepository = menuComponent.menuButtonsRepository();
- }
-
- public void resetMenu() {
- mMenuButtonsRepository.setCurrentMenu("main");
- }
-
- @Override
- public void show() {
- Gdx.input.setInputProcessor(mMenuInputProcessor);
- }
-
- @Override
- public void render(float delta) {
- mMenuRenderer.render(delta);
- }
-
- @Override
- public void resize(int width, int height) {
-
- }
-
- @Override
- public void pause() {
-
- }
-
- @Override
- public void resume() {
-
- }
-
- @Override
- public void hide() {
-
- }
-
- @Override
- public void dispose() {
-
- }
-}
+++ /dev/null
-package ru.deadsoftware.cavedroid
-
-import com.badlogic.gdx.Game
-import ru.fredboy.cavedroid.common.api.GameController
-
-abstract class BaseGame : Game(), GameController
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid
-
-import com.badlogic.gdx.Application
-import com.badlogic.gdx.Gdx
-import com.badlogic.gdx.graphics.OrthographicCamera
-import com.badlogic.gdx.math.Rectangle
-import ru.fredboy.cavedroid.common.api.PreferencesStore
-import ru.fredboy.cavedroid.common.utils.ratio
-import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
-
-class CaveGame(
- private val gameDataDirectoryPath: String,
- private val isTouchScreen: Boolean,
- private val isDebug: Boolean,
- private val preferencesStore: PreferencesStore,
-) : BaseGame() {
-
- private val mainComponent: MainComponent
- private val mainConfig: MainConfig
-
- private val mGameContextRepository: GameContextRepository
-
- init {
- mainComponent = DaggerMainComponent.builder()
- .caveGame(this)
- .preferencesStore(preferencesStore)
- .build()
-
- mainConfig = mainComponent.mainConfig
- mGameContextRepository = mainComponent.gameContextRepository
- }
-
- private fun initMainConfig() {
- val width = DEFAULT_VIEWPORT_WIDTH
- val height = width / Gdx.graphics.ratio
-
- mainConfig.mainComponent = mainComponent
-
- mGameContextRepository.apply {
- setGameDirectory(gameDataDirectoryPath)
- setTouch(isTouchScreen)
- setWidth(width)
- setHeight(height)
- setShowInfo(isDebug)
-
- setCameraContext(
- CameraContext(
- viewport = Rectangle(0f, 0f, width, height),
- camera = OrthographicCamera().apply {
- setToOrtho(true, width, height)
- }
- )
- )
- }
-
- Gdx.app.logLevel = if (isDebug) Application.LOG_DEBUG else Application.LOG_ERROR
- }
-
- fun newGame(gameMode: Int) {
- setScreen(mainComponent.gameScreen.apply { newGame(gameMode) })
- }
-
- override fun newGameCreative() {
- newGame(1)
- }
-
- override fun newGameSurvival() {
- newGame(0)
- }
-
- override fun loadGame() {
- setScreen(mainComponent.gameScreen.apply { loadGame() })
- }
-
- override fun quitGame() {
- screen?.dispose()
- setScreen(mainComponent.menuScreen.apply { resetMenu() })
- }
-
- override fun exitGame() {
- Gdx.app.exit()
- }
-
- override fun create() {
- Gdx.files.absolute(gameDataDirectoryPath).mkdirs()
- initMainConfig()
-
- mainComponent.initializeAssetsUseCase()
- setScreen(mainComponent.menuScreen)
- }
-
- override fun dispose() {
- screen?.dispose()
- mainComponent.disposeAssetsUseCase()
- }
-
-
- companion object {
- private const val TAG = "CaveGame"
- private const val DEFAULT_VIEWPORT_WIDTH = 480f
- }
-
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid
-
-import dagger.Binds
-import dagger.Module
-import ru.fredboy.cavedroid.common.api.GameController
-
-@Module
-abstract class GameModule {
-
- @Binds
- internal abstract fun bindGameController(impl: CaveGame): GameController
-
-}
\ No newline at end of file
+++ /dev/null
-package ru.deadsoftware.cavedroid
-
-import dagger.Component
-import ru.deadsoftware.cavedroid.game.GameScreen
-import ru.deadsoftware.cavedroid.menu.MenuScreen
-import ru.fredboy.cavedroid.common.api.PreferencesStore
-import ru.fredboy.cavedroid.common.api.GameController
-import ru.fredboy.cavedroid.data.assets.di.DataAssetsModule
-import ru.fredboy.cavedroid.data.configuration.di.DataConfigurationModule
-import ru.fredboy.cavedroid.data.items.di.DataItemsModule
-import ru.fredboy.cavedroid.data.save.di.DataSaveModule
-import ru.fredboy.cavedroid.domain.assets.repository.*
-import ru.fredboy.cavedroid.domain.assets.usecase.DisposeAssetsUseCase
-import ru.fredboy.cavedroid.domain.assets.usecase.InitializeAssetsUseCase
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
-import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
-import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
-import javax.inject.Singleton
-
-@Singleton
-@Component(
- dependencies = [CaveGame::class, PreferencesStore::class],
- modules = [DataAssetsModule::class, DataItemsModule::class, DataSaveModule::class, DataConfigurationModule::class, GameModule::class]
-)
-interface MainComponent {
-
- val gameScreen: GameScreen
-
- val menuScreen: MenuScreen
-
- val mainConfig: MainConfig
-
- val initializeAssetsUseCase: InitializeAssetsUseCase
-
- val disposeAssetsUseCase: DisposeAssetsUseCase
-
- val blockAssetsRepository: BlockAssetsRepository
-
- val blockDamageAssetsRepository: BlockDamageAssetsRepository
-
- val fontAssetsRepository: FontAssetsRepository
-
- val mobAssetsRepository: MobAssetsRepository
-
- val itemAssetsRepository: ItemsAssetsRepository
-
- val textureRegionsAssetsRepository: TextureRegionsAssetsRepository
-
- val touchButtonsAssetsRepository: TouchButtonsAssetsRepository
-
- val itemsRepository: ItemsRepository
-
- val saveDataRepository: SaveDataRepository
-
- val gameContextRepository: GameContextRepository
-
- val gameController: GameController
-
-}
\ No newline at end of file
import ru.fredboy.cavedroid.domain.assets.model.TouchButton
import ru.fredboy.cavedroid.domain.assets.usecase.GetTouchButtonsUseCase
import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.window.GameWindowType
@GameScope
class GameInputProcessor @Inject constructor(
+ private val applicationContextRepository: ApplicationContextRepository,
private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
private val getTouchButtonsUseCase: GetTouchButtonsUseCase,
private val mouseLeftTouchButton = TouchButton(
Rectangle(
- /* x = */ gameContextRepository.getWidth() / 2,
+ /* x = */ applicationContextRepository.getWidth() / 2,
/* y = */ 0f,
- /* width = */ gameContextRepository.getWidth() / 2,
- /* height = */ gameContextRepository.getHeight() / 2
+ /* width = */ applicationContextRepository.getWidth() / 2,
+ /* height = */ applicationContextRepository.getHeight() / 2
),
Input.Buttons.LEFT,
true
private val mouseRightTouchButton = TouchButton(
Rectangle(
- /* x = */ gameContextRepository.getWidth() / 2,
- /* y = */ gameContextRepository.getHeight() / 2,
- /* width = */ gameContextRepository.getWidth() / 2,
- /* height = */ gameContextRepository.getHeight() / 2
+ /* x = */ applicationContextRepository.getWidth() / 2,
+ /* y = */ applicationContextRepository.getHeight() / 2,
+ /* width = */ applicationContextRepository.getWidth() / 2,
+ /* height = */ applicationContextRepository.getHeight() / 2
),
Input.Buttons.RIGHT,
true
touchDownX = touchX
touchDownY = touchY
- if (gameContextRepository.isTouch()) {
+ if (applicationContextRepository.isTouch()) {
val touchedKey = getTouchedKey(touchX, touchY)
return if (touchedKey.isMouse) {
onMouseActionEvent(
val joy: Joystick? = gameContextRepository.getJoystick()
- if (gameContextRepository.isTouch()) {
+ if (applicationContextRepository.isTouch()) {
if (joy != null && joy.active && joy.pointer == pointer) {
return onMouseActionEvent(
mouseX = screenX,
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class FlyDownKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Down &&
mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class FlyUpKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
return action.actionKey is KeyboardInputActionKey.Up &&
!mobController.player.swim &&
mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class GoLeftKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
- val isTouch = gameContextRepository.isTouch()
+ val isTouch = applicationContextRepository.isTouch()
return action.actionKey is KeyboardInputActionKey.Left &&
(mobController.player.controlMode == Player.ControlMode.WALK || !isTouch) &&
(mobController.player.controlMode == Player.ControlMode.WALK || !isTouch)
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class GoRightKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Right &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class JumpKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
return action.actionKey is KeyboardInputActionKey.Up &&
mobController.player.canJump && !mobController.player.isFlyMode &&
action.isKeyDown &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class MoveCursorControlsModeKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobsController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
- return gameContextRepository.isTouch() &&
+ return applicationContextRepository.isTouch() &&
mobsController.player.controlMode == Player.ControlMode.CURSOR && action.isKeyDown &&
(action.actionKey is KeyboardInputActionKey.Left ||
action.actionKey is KeyboardInputActionKey.Right ||
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
-import ru.fredboy.cavedroid.common.api.GameController
+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
@GameScope
@BindKeyboardInputHandler
class PauseGameKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
- private val gameController: GameController,
+ private val applicationContextRepository: ApplicationContextRepository,
+ private val gameController: ApplicationController,
private val dropController: DropController,
private val mobController: MobController,
private val gameWorld: GameWorld,
}
saveDataRepository.save(
- gameDataFolder = gameContextRepository.getGameDirectory(),
+ gameDataFolder = applicationContextRepository.getGameDirectory(),
dropController = dropController,
mobController = mobController,
containerController = containerController,
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class StopSwimKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Up && !action.isKeyDown &&
mobController.player.swim &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class SwimUpKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
private val gameWorld: GameWorld,
) : IKeyboardInputHandler {
!mobController.player.swim &&
!mobController.player.canJump &&
checkSwim() && !mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class ToggleControlsModeKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.SwitchControlsMode && !action.isKeyDown
- && gameContextRepository.isTouch()
+ && applicationContextRepository.isTouch()
}
override fun handle(action: KeyboardInputAction) {
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
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
@GameScope
@BindKeyboardInputHandler
class TurnOnFlyModeKeyboardInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobsController: MobController,
) : IKeyboardInputHandler {
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 || !gameContextRepository.isTouch())
+ (mobsController.player.controlMode == Player.ControlMode.WALK || !applicationContextRepository.isTouch())
}
override fun handle(action: KeyboardInputAction) {
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.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
@GameScope
@BindMouseInputHandler
class CreativeInventoryScrollMouseInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val gameWindowsManager: GameWindowsManager,
private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
}
private fun checkDragConditions(action: MouseInputAction): Boolean {
- return gameContextRepository.isTouch() && action.actionKey is MouseInputActionKey.Dragged &&
+ return applicationContextRepository.isTouch() && action.actionKey is MouseInputActionKey.Dragged &&
abs(action.screenY - dragStartY) >= DRAG_SENSITIVITY
}
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.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
@GameScope
@BindMouseInputHandler
class CursorMouseInputHandler @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
private val gameWorld: GameWorld,
private val gameWindowsManager: GameWindowsManager,
val pastCursorY = player.cursorY
when {
- player.controlMode == Player.ControlMode.WALK && gameContextRepository.isTouch() -> handleWalkTouch()
- !gameContextRepository.isTouch() -> handleMouse(action)
+ player.controlMode == Player.ControlMode.WALK && applicationContextRepository.isTouch() -> handleWalkTouch()
+ !applicationContextRepository.isTouch() -> handleMouse(action)
}
mobController.checkPlayerCursorBounds()
- if (player.controlMode == Player.ControlMode.WALK && gameContextRepository.isTouch()) {
+ if (player.controlMode == Player.ControlMode.WALK && applicationContextRepository.isTouch()) {
setPlayerDirectionToCursor()
}
import ru.fredboy.cavedroid.common.di.GameScope
import ru.fredboy.cavedroid.common.model.Joystick
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.entity.mob.model.Player
@GameScope
@BindMouseInputHandler
class JoystickInputHandler @Inject constructor(
+ private val applicationContextRepository: ApplicationContextRepository,
private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == GameWindowType.NONE &&
- gameContextRepository.isTouch() &&
+ applicationContextRepository.isTouch() &&
// mobsController.player.controlMode == Player.ControlMode.WALK &&
gameContextRepository.getJoystick() != null &&
(action.actionKey is MouseInputActionKey.Touch) &&
- (action.actionKey.pointer == gameContextRepository.getJoystick()?.pointer || !active) &&
+ (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 key = action.actionKey as MouseInputActionKey.Screen
- gameContextRepository.getJoystick()?.activate(action.screenX, action.screenY, key.pointer) ?: return
+ gameContextRepository.getJoystick().activate(action.screenX, action.screenY, key.pointer)
active = true
}
}
private fun handleCursor() {
- val joystick = gameContextRepository.getJoystick() ?: return
+ val joystick = gameContextRepository.getJoystick()
if (TimeUtils.timeSinceMillis(cursorTimeoutMs) < 150L) {
return
return
}
- val joystick = gameContextRepository.getJoystick() ?: return
+ val joystick = gameContextRepository.getJoystick()
val joyVector = joystick.getVelocityVector()
if (mobController.player.isFlyMode) {
import com.badlogic.gdx.Input
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
@GameScope
class MouseInputActionMapper @Inject constructor(
- val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
) {
fun map(
}
private fun getScreenX(mouseX: Float): Float {
- return mouseX * (gameContextRepository.getWidth() / Gdx.graphics.width)
+ return mouseX * (applicationContextRepository.getWidth() / Gdx.graphics.width)
}
private fun getScreenY(mouseY: Float): Float {
- return mouseY * (gameContextRepository.getHeight() / Gdx.graphics.height)
+ return mouseY * (applicationContextRepository.getHeight() / Gdx.graphics.height)
}
}
\ No newline at end of file
import org.jetbrains.annotations.Nullable;
import ru.fredboy.cavedroid.common.di.GameScope;
import ru.fredboy.cavedroid.common.utils.MeasureUnitsUtilsKt;
+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.model.inventory.InventoryItem;
private final Vector2 gravity = new Vector2(0, 444.44f);
private final GameWorld mGameWorld;
- private final GameContextRepository mGameContextRepository;
+ private final ApplicationContextRepository mGameContextRepository;
private final MobController mMobController;
private final DropController mDropController;
private final GetItemByKeyUseCase mGetItemByKeyUseCase;
@Inject
public GamePhysics(GameWorld gameWorld,
- GameContextRepository gameContextRepository,
+ ApplicationContextRepository gameContextRepository,
MobController mobController,
DropController dropController,
GetItemByKeyUseCase getItemByKeyUseCase) {
import ru.fredboy.cavedroid.common.utils.RenderingUtilsKt;
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase;
import ru.fredboy.cavedroid.domain.configuration.model.CameraContext;
+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;
private static final float CAMERA_SPEED = 72f;
private static final float MAX_CAM_DISTANCE_FROM_PLAYER = 64f;
+ private final ApplicationContextRepository mApplicationContextRepository;
private final GameContextRepository mGameContextRepository;
private final MobController mMobsController;
private final GameWorld mGameWorld;
private final SpriteBatch spriter;
@Inject
- public GameRenderer(GameContextRepository gameContextRepository,
+ public GameRenderer(ApplicationContextRepository applicationContextRepository,
+ GameContextRepository gameContextRepository,
MobController mobsController,
GameWorld gameWorld,
Set<IGameRenderer> renderers,
Gdx.app.error("GameRenderer", "Camera context was not set");
}
+ mApplicationContextRepository = applicationContextRepository;
mGameContextRepository = gameContextRepository;
mMobsController = mobsController;
mGameWorld = gameWorld;
}
private float getWidth() {
- return mGameContextRepository.getWidth();
+ return mApplicationContextRepository.getWidth();
}
private float getHeight() {
- return mGameContextRepository.getHeight();
+ return mApplicationContextRepository.getHeight();
}
private void setCamPos(float x, float y) {
float camTargetX, camTargetY;
- boolean followPlayer = player.getControlMode() == Player.ControlMode.WALK || !mGameContextRepository.isTouch();
+ boolean followPlayer = player.getControlMode() == Player.ControlMode.WALK || !mApplicationContextRepository.isTouch();
if (followPlayer) {
camTargetX = plTargetX + Math.min(player.getVelocity().x * 2, getWidth() / 2);
import ru.fredboy.cavedroid.common.utils.drawSprite
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
import ru.fredboy.cavedroid.domain.assets.usecase.GetTouchButtonsUseCase
+import ru.fredboy.cavedroid.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
@GameScope
@BindRenderer
class TouchControlsRenderer @Inject constructor(
+ private val applicationContextRepository: ApplicationContextRepository,
private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val joyStick = Sprite(textureRegions["joy_stick"])
private fun drawJoystick(spriteBatch: SpriteBatch) {
- val joystick = gameContextRepository.getJoystick()?.takeIf { it.active } ?: return
+ val joystick = gameContextRepository.getJoystick().takeIf { it.active } ?: return
spriteBatch.drawSprite(
sprite = joyBackground,
}
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
- if (!gameContextRepository.isTouch() || gameWindowsManager.currentWindowType != GameWindowType.NONE) {
+ if (!applicationContextRepository.isTouch() || gameWindowsManager.currentWindowType != GameWindowType.NONE) {
return
}
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
@GameScope
class SurvivalWindowRenderer @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val textureRegions: GetTextureRegionByNameUseCase,
private val survivalWindowTexture get() = requireNotNull(textureRegions[SURVIVAL_WINDOW_KEY])
private fun setPortraitHeadRotation(portraitX: Float, portraitY: Float) {
- if (gameContextRepository.isTouch()) {
+ if (applicationContextRepository.isTouch()) {
return
}
- val mouseX = Gdx.input.x * (gameContextRepository.getWidth() / Gdx.graphics.width)
- val mouseY = Gdx.input.y * (gameContextRepository.getHeight() / Gdx.graphics.height)
+ val mouseX = Gdx.input.x * (applicationContextRepository.getWidth() / Gdx.graphics.width)
+ val mouseY = Gdx.input.y * (applicationContextRepository.getHeight() / Gdx.graphics.height)
val h = mouseX.toDouble() - portraitX.toDouble()
val v = mouseY.toDouble() - portraitY.toDouble()
useDagger()
useCommonModule()
+ useDataModules()
useDomainModules()
useEntityModules()
useGameModules()
-package ru.deadsoftware.cavedroid.game;
+package ru.fredboy.cavedroid.zygote.game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.utils.Disposable;
import com.badlogic.gdx.utils.Timer;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository;
import ru.fredboy.cavedroid.ux.controls.GameInputProcessor;
import ru.fredboy.cavedroid.ux.physics.GamePhysics;
import ru.fredboy.cavedroid.ux.physics.task.GameWorldBlocksLogicControllerTask;
private final Timer mWorldLogicTimer = new Timer();
@Inject
- public GameProc(GameContextRepository gameContextRepository,
+ public GameProc(ApplicationContextRepository gameContextRepository,
GamePhysics gamePhysics,
GameRenderer gameRenderer,
MobController mobsController,
--- /dev/null
+package ru.fredboy.cavedroid.zygote
+
+import com.badlogic.gdx.Application
+import com.badlogic.gdx.Game
+import com.badlogic.gdx.Gdx
+import ru.fredboy.cavedroid.common.api.ApplicationController
+import ru.fredboy.cavedroid.common.api.PreferencesStore
+import ru.fredboy.cavedroid.common.utils.ratio
+import ru.fredboy.cavedroid.data.configuration.model.ApplicationContext
+import ru.fredboy.cavedroid.zygote.di.ApplicationComponent
+import ru.fredboy.cavedroid.zygote.di.DaggerApplicationComponent
+import ru.fredboy.cavedroid.zygote.game.GameScreen
+
+class CaveDroidApplication(
+ private val gameDataDirectoryPath: String,
+ private val isTouchScreen: Boolean,
+ private val isDebug: Boolean,
+ private val preferencesStore: PreferencesStore,
+) : Game(), ApplicationController {
+
+ lateinit var applicationComponent: ApplicationComponent
+ private set
+
+ private fun newGame(gameMode: Int) {
+ setScreen(applicationComponent.gameScreen.apply { newGame(gameMode) })
+ }
+
+ override fun create() {
+ val width = DEFAULT_VIEWPORT_WIDTH
+ val height = width / Gdx.graphics.ratio
+
+ applicationComponent = DaggerApplicationComponent.builder()
+ .applicationContext(
+ ApplicationContext(
+ isDebug = isDebug,
+ isTouch = isTouchScreen,
+ gameDirectory = gameDataDirectoryPath,
+ width = width,
+ height = height,
+ )
+ )
+ .applicationController(this)
+ .preferencesStore(preferencesStore)
+ .build()
+
+ Gdx.app.logLevel = Application.LOG_DEBUG
+
+ Gdx.files.absolute(gameDataDirectoryPath).mkdirs()
+ applicationComponent.initializeAssets()
+ setScreen(applicationComponent.menuScreen)
+ }
+
+ override fun dispose() {
+ applicationComponent.menuScreen.dispose()
+ applicationComponent.gameScreen.dispose()
+ applicationComponent.disposeAssets()
+ }
+
+ override fun quitGame() {
+ (screen as? GameScreen)?.let { gameScreen ->
+ screen.dispose()
+ setScreen(applicationComponent.menuScreen)
+ } ?: Gdx.app.error(TAG, "quitGame called when active screen is not Game")
+ }
+
+ override fun newGameCreative() {
+ newGame(1)
+ }
+
+ override fun newGameSurvival() {
+ newGame(0)
+ }
+
+ override fun loadGame() {
+ setScreen(applicationComponent.gameScreen.apply { loadGame() })
+ }
+
+ override fun exitGame() {
+ setScreen(null)
+ Gdx.app.exit()
+ }
+
+ companion object {
+ private const val TAG = "CaveDroidApplication"
+ private const val DEFAULT_VIEWPORT_WIDTH = 480f
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.zygote.di
+
+import dagger.BindsInstance
+import dagger.Component
+import ru.fredboy.cavedroid.common.api.ApplicationController
+import ru.fredboy.cavedroid.common.api.PreferencesStore
+import ru.fredboy.cavedroid.data.assets.di.DataAssetsModule
+import ru.fredboy.cavedroid.data.configuration.di.ApplicationContextModule
+import ru.fredboy.cavedroid.data.configuration.model.ApplicationContext
+import ru.fredboy.cavedroid.data.items.di.DataItemsModule
+import ru.fredboy.cavedroid.data.save.di.DataSaveModule
+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 ru.fredboy.cavedroid.domain.assets.usecase.DisposeAssetsUseCase
+import ru.fredboy.cavedroid.domain.assets.usecase.InitializeAssetsUseCase
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
+import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
+import ru.fredboy.cavedroid.zygote.game.GameScreen
+import ru.fredboy.cavedroid.zygote.menu.MenuScreen
+import javax.inject.Singleton
+
+@Singleton
+@Component(
+ modules = [
+ DataAssetsModule::class,
+ DataItemsModule::class,
+ DataSaveModule::class,
+ ApplicationContextModule::class,
+ ]
+)
+interface ApplicationComponent {
+
+ val initializeAssets: InitializeAssetsUseCase
+
+ val disposeAssets: DisposeAssetsUseCase
+
+ val gameScreen: GameScreen
+
+ val menuScreen: MenuScreen
+
+ val applicationContextRepository: ApplicationContextRepository
+
+ val blockAssetsRepository: BlockAssetsRepository
+
+ val blockDamageAssetsRepository: BlockDamageAssetsRepository
+
+ val fontAssetsRepository: FontAssetsRepository
+
+ val mobAssetsRepository: MobAssetsRepository
+
+ val itemAssetsRepository: ItemsAssetsRepository
+
+ val textureRegionsAssetsRepository: TextureRegionsAssetsRepository
+
+ val touchButtonsAssetsRepository: TouchButtonsAssetsRepository
+
+ val itemsRepository: ItemsRepository
+
+ val saveDataRepository: SaveDataRepository
+
+ val applicationController: ApplicationController
+
+ @Component.Builder
+ interface Builder {
+
+ @BindsInstance
+ fun applicationContext(context: ApplicationContext): Builder
+
+ @BindsInstance
+ fun applicationController(impl: ApplicationController): Builder
+
+ @BindsInstance
+ fun preferencesStore(impl: PreferencesStore): Builder
+
+ fun build(): ApplicationComponent
+
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.zygote.game
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.Screen
+import com.badlogic.gdx.graphics.OrthographicCamera
+import com.badlogic.gdx.math.Rectangle
+import ru.fredboy.cavedroid.common.model.Joystick
+import ru.fredboy.cavedroid.data.configuration.model.GameContext
+import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
+import ru.fredboy.cavedroid.entity.mob.model.Player
+import ru.fredboy.cavedroid.zygote.CaveDroidApplication
+import ru.fredboy.cavedroid.zygote.game.di.DaggerGameComponent
+import ru.fredboy.cavedroid.zygote.game.di.GameComponent
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class GameScreen @Inject constructor(
+ private val applicationContextRepository: ApplicationContextRepository,
+) : Screen {
+
+ private var gameProc: GameProc? = null
+
+ private fun getGameContext(isLoadGame: Boolean): GameContext {
+ return GameContext(
+ isLoadGame = isLoadGame,
+ showInfo = false,
+ showMap = false,
+ isFullscreen = false,
+ useDynamicCamera = false,
+ joystick = Joystick(Player.SPEED),
+ cameraContext = CameraContext(
+ viewport = Rectangle(
+ /* x = */ 0f,
+ /* y = */ 0f,
+ /* width = */ applicationContextRepository.getWidth(),
+ /* height = */ applicationContextRepository.getHeight(),
+ ),
+ camera = OrthographicCamera().apply {
+ setToOrtho(
+ /* yDown = */ true,
+ /* viewportWidth = */ applicationContextRepository.getWidth(),
+ /* viewportHeight = */ applicationContextRepository.getHeight(),
+ )
+ }
+ )
+ )
+ }
+
+ private fun getGameComponent(isLoadGame: Boolean): GameComponent {
+ val gameContext = getGameContext(isLoadGame)
+
+ return DaggerGameComponent.builder()
+ .applicationComponent((Gdx.app.applicationListener as CaveDroidApplication).applicationComponent)
+ .gameContext(gameContext)
+ .build()
+ }
+
+ private fun resetGameProc() {
+ gameProc?.dispose()
+ gameProc = null
+ }
+
+ fun newGame(gameMode: Int) {
+ resetGameProc()
+ gameProc = getGameComponent(false).gameProc.apply {
+ setPlayerGameMode(gameMode)
+ }
+ }
+
+ fun loadGame() {
+ resetGameProc()
+ gameProc = getGameComponent(true).gameProc
+ }
+
+ override fun show() {
+ val proc = requireNotNull(gameProc) {
+ "GameScreen#show: gameProc was not set before show"
+ }
+ proc.show()
+ }
+
+ override fun render(delta: Float) {
+ val proc = requireNotNull(gameProc) {
+ "GameScreen#render: gameProc was not set before render"
+ }
+ proc.update(delta)
+ }
+
+ override fun resize(width: Int, height: Int) {
+
+ }
+
+ override fun pause() {
+
+ }
+
+ override fun resume() {
+
+ }
+
+ override fun hide() {
+
+ }
+
+ override fun dispose() {
+ resetGameProc()
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.zygote.game.di
+
+import dagger.BindsInstance
+import dagger.Component
+import ru.deadsoftware.cavedroid.generated.module.*
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.data.configuration.di.GameContextModule
+import ru.fredboy.cavedroid.data.configuration.model.GameContext
+import ru.fredboy.cavedroid.game.controller.container.di.ControllerContainerModule
+import ru.fredboy.cavedroid.game.controller.drop.di.ControllerDropModule
+import ru.fredboy.cavedroid.game.world.di.GameWorldModule
+import ru.fredboy.cavedroid.zygote.di.ApplicationComponent
+import ru.fredboy.cavedroid.zygote.game.GameProc
+
+@GameScope
+@Component(
+ dependencies = [ ApplicationComponent::class ],
+ modules = [
+ GameModule::class,
+ UseItemActionsModule::class,
+ UpdateBlockActionsModule::class,
+ PlaceBlockActionsModule::class,
+ RenderModule::class,
+ KeyboardInputHandlersModule::class,
+ MouseInputHandlersModule::class,
+ UseBlockActionsModule::class,
+ GameWorldModule::class,
+ ControllerContainerModule::class,
+ ControllerDropModule::class,
+ GameContextModule::class,
+ ]
+)
+interface GameComponent {
+
+ val gameProc: GameProc
+
+ @Component.Builder
+ interface Builder {
+
+ fun applicationComponent(component: ApplicationComponent): Builder
+
+ @BindsInstance
+ fun gameContext(context: GameContext): Builder
+
+ fun build(): GameComponent
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.zygote.game.di
+
+import dagger.Module
+import dagger.Provides
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository
+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.domain.items.usecase.GetFallbackItemUseCase
+import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase
+import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerFactory
+import ru.fredboy.cavedroid.entity.container.abstraction.ContainerWorldAdapter
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropAdapter
+import ru.fredboy.cavedroid.entity.drop.abstraction.DropWorldAdapter
+import ru.fredboy.cavedroid.entity.mob.abstraction.MobWorldAdapter
+import ru.fredboy.cavedroid.game.controller.container.ContainerController
+import ru.fredboy.cavedroid.game.controller.drop.DropController
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.world.GameWorld
+
+@Module
+object GameModule {
+
+ @Provides
+ @GameScope
+ fun provideDropController(
+ applicationContextRepository: ApplicationContextRepository,
+ gameContextRepository: GameContextRepository,
+ saveDataRepository: SaveDataRepository,
+ itemsRepository: ItemsRepository,
+ dropWorldAdapter: DropWorldAdapter,
+ ): DropController {
+ return if (gameContextRepository.isLoadGame()) {
+ saveDataRepository.loadDropController(
+ gameDataFolder = applicationContextRepository.getGameDirectory(),
+ dropWorldAdapter = dropWorldAdapter,
+ )
+ } else {
+ DropController(
+ itemsRepository = itemsRepository,
+ dropWorldAdapter = dropWorldAdapter,
+ )
+ }
+ }
+
+ @Provides
+ @GameScope
+ fun provideContainerController(
+ applicationContextRepository: ApplicationContextRepository,
+ gameContextRepository: GameContextRepository,
+ saveDataRepository: SaveDataRepository,
+ getItemByKeyUseCase: GetItemByKeyUseCase,
+ containerWorldAdapter: ContainerWorldAdapter,
+ containerFactory: ContainerFactory,
+ dropAdapter: DropAdapter,
+ ): ContainerController {
+ return if (gameContextRepository.isLoadGame()) {
+ saveDataRepository.loadContainerController(
+ gameDataFolder = applicationContextRepository.getGameDirectory(),
+ containerWorldAdapter = containerWorldAdapter,
+ containerFactory = containerFactory,
+ dropAdapter = dropAdapter,
+ )
+ } else {
+ ContainerController(
+ getItemByKeyUseCase = getItemByKeyUseCase,
+ containerWorldAdapter = containerWorldAdapter,
+ containerFactory = containerFactory,
+ dropAdapter = dropAdapter,
+ )
+ }
+ }
+
+ @Provides
+ @GameScope
+ fun provideMobController(
+ applicationContextRepository: ApplicationContextRepository,
+ gameContextRepository: GameContextRepository,
+ saveDataRepository: SaveDataRepository,
+ mobAssetsRepository: MobAssetsRepository,
+ getFallbackItemUseCase: GetFallbackItemUseCase,
+ mobWorldAdapter: MobWorldAdapter,
+ ): MobController {
+ return if (gameContextRepository.isLoadGame()) {
+ saveDataRepository.loadMobController(
+ gameDataFolder = applicationContextRepository.getGameDirectory(),
+ mobWorldAdapter = mobWorldAdapter,
+ )
+ } else {
+ MobController(
+ mobAssetsRepository = mobAssetsRepository,
+ getFallbackItemUseCase = getFallbackItemUseCase,
+ mobWorldAdapter = mobWorldAdapter,
+ )
+ }
+ }
+
+ @Provides
+ @GameScope
+ fun provideGameWorld(
+ applicationContextRepository: ApplicationContextRepository,
+ gameContextRepository: GameContextRepository,
+ saveDataRepository: SaveDataRepository,
+ itemsRepository: ItemsRepository,
+ ): GameWorld {
+ val mapData = if (gameContextRepository.isLoadGame()) {
+ saveDataRepository.loadMap(
+ gameDataFolder = applicationContextRepository.getGameDirectory(),
+ )
+ } else {
+ null
+ }
+
+ return GameWorld(
+ itemsRepository = itemsRepository,
+ initialForeMap = mapData?.retrieveForeMap(),
+ initialBackMap = mapData?.retrieveBackMap(),
+ )
+ }
+}
\ No newline at end of file
--- /dev/null
+package ru.fredboy.cavedroid.zygote.menu
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.Screen
+import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
+import ru.fredboy.cavedroid.zygote.CaveDroidApplication
+import ru.fredboy.cavedroid.zygote.menu.di.DaggerMenuComponent
+import ru.fredboy.cavedroid.zygote.menu.di.MenuComponent
+import ru.fredboy.cavedroid.zygote.menu.input.MenuInputProcessor
+import ru.fredboy.cavedroid.zygote.menu.renderer.MenuRenderer
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class MenuScreen @Inject constructor() : Screen {
+
+ private val menuRenderer: MenuRenderer
+
+ private val menuInputProcessor: MenuInputProcessor
+
+ private val menuButtonRepository: MenuButtonRepository
+
+ init {
+ val menuComponent: MenuComponent = DaggerMenuComponent.builder()
+ .applicationComponent((Gdx.app.applicationListener as CaveDroidApplication).applicationComponent)
+ .build()
+
+ menuRenderer = menuComponent.menuRenderer
+ menuInputProcessor = menuComponent.menuInputProcessor
+ menuButtonRepository = menuComponent.menuButtonRepository
+ }
+
+ fun resetMenu() {
+ menuButtonRepository.setCurrentMenu("main")
+ }
+
+ override fun show() {
+ Gdx.input.inputProcessor = menuInputProcessor
+ }
+
+ override fun render(delta: Float) {
+ menuRenderer.render(delta)
+ }
+
+ override fun resize(width: Int, height: Int) {
+ }
+
+ override fun pause() {
+ }
+
+ override fun resume() {
+ }
+
+ override fun hide() {
+ }
+
+ override fun dispose() {
+ menuRenderer.dispose()
+ menuButtonRepository.dispose()
+ }
+}
\ No newline at end of file
package ru.fredboy.cavedroid.zygote.menu.action
-import ru.fredboy.cavedroid.common.api.GameController
+import ru.fredboy.cavedroid.common.api.ApplicationController
import ru.fredboy.cavedroid.common.di.MenuScope
import ru.fredboy.cavedroid.zygote.menu.action.annotation.BindsMenuAction
import javax.inject.Inject
@MenuScope
@BindsMenuAction(stringKey = ExitGameAction.KEY)
class ExitGameAction @Inject constructor(
- private val gameController: GameController,
+ private val gameController: ApplicationController,
) : IMenuAction {
override fun perform() {
package ru.fredboy.cavedroid.zygote.menu.action
-import ru.fredboy.cavedroid.common.api.GameController
+import ru.fredboy.cavedroid.common.api.ApplicationController
import ru.fredboy.cavedroid.common.di.MenuScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
import ru.fredboy.cavedroid.zygote.menu.action.annotation.BindsMenuAction
import javax.inject.Inject
@MenuScope
@BindsMenuAction(stringKey = LoadGameAction.KEY)
class LoadGameAction @Inject constructor(
- private val gameController: GameController,
+ private val applicationContextRepository: ApplicationContextRepository,
+ private val gameController: ApplicationController,
private val saveDataRepository: SaveDataRepository,
- private val gameContextRepository: GameContextRepository,
) : IMenuAction {
override fun perform() {
}
override fun canPerform(): Boolean {
- return saveDataRepository.exists(gameContextRepository.getGameDirectory())
+ return saveDataRepository.exists(applicationContextRepository.getGameDirectory())
}
companion object {
package ru.fredboy.cavedroid.zygote.menu.action
-import ru.fredboy.cavedroid.common.api.GameController
+import ru.fredboy.cavedroid.common.api.ApplicationController
import ru.fredboy.cavedroid.common.di.MenuScope
import ru.fredboy.cavedroid.zygote.menu.action.annotation.BindsMenuAction
import javax.inject.Inject
@MenuScope
@BindsMenuAction(stringKey = NewGameCreativeAction.KEY)
class NewGameCreativeAction @Inject constructor(
- private val gameController: GameController,
+ private val gameController: ApplicationController,
) : IMenuAction {
override fun perform() {
package ru.fredboy.cavedroid.zygote.menu.action
-import ru.fredboy.cavedroid.common.api.GameController
+import ru.fredboy.cavedroid.common.api.ApplicationController
import ru.fredboy.cavedroid.common.di.MenuScope
import ru.fredboy.cavedroid.zygote.menu.action.annotation.BindsMenuAction
import javax.inject.Inject
@MenuScope
@BindsMenuAction(stringKey = NewGameSurvivalAction.KEY)
class NewGameSurvivalAction @Inject constructor(
- private val gameController: GameController,
+ private val gameController: ApplicationController,
) : IMenuAction {
override fun perform() {
--- /dev/null
+package ru.fredboy.cavedroid.zygote.menu.di
+
+import dagger.Component
+import ru.deadsoftware.cavedroid.generated.module.MenuActionsModule
+import ru.deadsoftware.cavedroid.generated.module.MenuBooleanOptionsModule
+import ru.fredboy.cavedroid.common.di.MenuScope
+import ru.fredboy.cavedroid.data.menu.di.DataMenuModule
+import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
+import ru.fredboy.cavedroid.zygote.di.ApplicationComponent
+import ru.fredboy.cavedroid.zygote.menu.input.MenuInputProcessor
+import ru.fredboy.cavedroid.zygote.menu.renderer.MenuRenderer
+
+@MenuScope
+@Component(
+ dependencies = [ ApplicationComponent::class ],
+ modules = [
+ DataMenuModule::class,
+ MenuBooleanOptionsModule::class,
+ MenuActionsModule::class,
+ ]
+)
+interface MenuComponent {
+
+ val menuRenderer: MenuRenderer
+
+ val menuInputProcessor: MenuInputProcessor
+
+ val menuButtonRepository: MenuButtonRepository
+
+ @Component.Builder
+ interface Builder {
+
+ fun applicationComponent(impl: ApplicationComponent): Builder
+
+ fun build(): MenuComponent
+ }
+}
import com.badlogic.gdx.InputProcessor
import com.badlogic.gdx.math.Rectangle
import ru.fredboy.cavedroid.common.di.MenuScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
import ru.fredboy.cavedroid.domain.menu.model.MenuButton
import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
import ru.fredboy.cavedroid.zygote.menu.action.IMenuAction
@MenuScope
class MenuInputProcessor @Inject constructor(
- private val gameContextRepository: GameContextRepository,
+ private val applicationContextRepository: ApplicationContextRepository,
private val menuButtonRepository: MenuButtonRepository,
private val menuButtonActions: Map<String, @JvmSuppressWildcards IMenuAction>,
private val menuButtonBooleanOption: Map<String, @JvmSuppressWildcards IMenuBooleanOption>,
pointer: Int,
button: Int
): Boolean {
- val cameraContext = gameContextRepository.getCameraContext() ?: return false
-
- val (touchX, touchY) = cameraContext.getViewportCoordinates(screenX, screenY)
+ val touchX = applicationContextRepository.getWidth() / Gdx.graphics.width * screenX.toFloat()
+ val touchY = applicationContextRepository.getHeight() / Gdx.graphics.height * screenY.toFloat()
menuButtonRepository.getCurrentMenuButtons()?.values?.forEachIndexed { index, button ->
if (!button.isEnabled) {
// TODO: Fix magic numbers
val rect = Rectangle(
- /* x = */ gameContextRepository.getWidth() / 2 - 100,
- /* y = */ gameContextRepository.getHeight() / 4 + index * 30,
+ /* x = */ applicationContextRepository.getWidth() / 2 - 100,
+ /* y = */ applicationContextRepository.getHeight() / 4 + index * 30,
/* width = */ 200f,
/* height = */ 20f
)
package ru.fredboy.cavedroid.zygote.menu.option.bool
import ru.fredboy.cavedroid.common.di.MenuScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
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 gameContextRepository: GameContextRepository,
) : IMenuBooleanOption {
override fun getOption(): Boolean {
- return gameContextRepository.useDynamicCamera()
+ return false
+// return gameContextRepository.useDynamicCamera()
}
override fun toggleOption() {
- gameContextRepository.setUseDynamicCamera(!getOption())
+// gameContextRepository.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.GameContextRepository
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 gameContextRepository: GameContextRepository,
) : IMenuBooleanOption {
override fun getOption(): Boolean {
- return gameContextRepository.isFullscreen()
+ return false
+// return gameContextRepository.isFullscreen()
}
override fun toggleOption() {
- gameContextRepository.setFullscreen(!getOption())
+// gameContextRepository.setFullscreen(!getOption())
}
companion object {
package ru.fredboy.cavedroid.zygote.menu.renderer
import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.OrthographicCamera
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.math.Rectangle
import ru.fredboy.cavedroid.common.CaveDroidConstants
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.GameContextRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.ApplicationContextRepository
import ru.fredboy.cavedroid.domain.menu.model.MenuButton
import ru.fredboy.cavedroid.domain.menu.repository.MenuButtonRepository
import ru.fredboy.cavedroid.zygote.menu.action.IMenuAction
@MenuScope
class MenuRenderer @Inject constructor(
+ private val applicationContextRepository: ApplicationContextRepository,
private val menuButtonRepository: MenuButtonRepository,
- private val gameContextRepository: GameContextRepository,
private val getTextureRegionByName: GetTextureRegionByNameUseCase,
private val menuButtonActions: Map<String, @JvmSuppressWildcards IMenuAction>,
private val buttonBooleanOptions: Map<String, @JvmSuppressWildcards IMenuBooleanOption>,
private val getStringWidth: GetStringWidthUseCase,
private val getStringHeight: GetStringHeightUseCase,
) {
+
+ private val camera = OrthographicCamera()
+
private val spriter = SpriteBatch()
init {
- val cameraContext = requireNotNull(gameContextRepository.getCameraContext()) {
- "$TAG: CameraContext was not set"
- }
+ camera.setToOrtho(
+ /* yDown = */ true,
+ /* viewportWidth = */ applicationContextRepository.getWidth(),
+ /* viewportHeight = */ applicationContextRepository.getHeight(),
+ )
- spriter.projectionMatrix = cameraContext.camera.combined
+ spriter.projectionMatrix = camera.combined
}
private fun getButtonTextureRegionKey(button: MenuButton): String {
)
}
- val buttonX = gameContextRepository.getWidth() / 2 - textureRegion.regionWidth / 2
- val buttonY = gameContextRepository.getHeight() / 4 + position.toFloat() * 30
+ val buttonX = applicationContextRepository.getWidth() / 2 - textureRegion.regionWidth / 2
+ val buttonY = applicationContextRepository.getHeight() / 4 + position.toFloat() * 30
val buttonRect = Rectangle(
/* x = */ buttonX,
/* height = */ textureRegion.regionHeight.toFloat(),
)
- val inputCoordinates = gameContextRepository.getCameraContext()?.getViewportCoordinates(
- x = Gdx.input.x,
- y = Gdx.input.y,
- )
+ val inputX = applicationContextRepository.getWidth() / Gdx.graphics.width * Gdx.input.x.toFloat()
+ val inputY = applicationContextRepository.getHeight() / Gdx.graphics.height * Gdx.input.y.toFloat()
spriter.draw(
- if (button.isEnabled && inputCoordinates != null && buttonRect.contains(
- /* x = */ inputCoordinates.first,
- /* y = */ inputCoordinates.second
- )
- ) {
+ if (button.isEnabled && buttonRect.contains(inputX, inputY)) {
getTextureRegionByName[KEY_BUTTON_SELECTED_TEXTURE] ?: textureRegion
} else {
textureRegion
val backgroundRegionWidth = backgroundRegion.regionWidth
val backgroundRegionHeight = backgroundRegion.regionWidth
- for (x in 0 .. gameContextRepository.getWidth().toInt() / backgroundRegionWidth) {
- for (y in 0 .. gameContextRepository.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(),
spriter.draw(
/* region = */ gameLogo,
- /* x = */ gameContextRepository.getWidth() / 2 - gameLogo.regionWidth.toFloat() / 2,
+ /* x = */ applicationContextRepository.getWidth() / 2 - gameLogo.regionWidth.toFloat() / 2,
/* y = */ 8f,
)
}
font = getFont(),
str = "CaveDroid " + CaveDroidConstants.VERSION,
x = 0f,
- y = gameContextRepository.getHeight() - getStringHeight("CaveDroid " + CaveDroidConstants.VERSION) * 1.5f,
+ y = applicationContextRepository.getHeight() - getStringHeight("CaveDroid " + CaveDroidConstants.VERSION) * 1.5f,
);
spriter.end()
dependencies {
useCommonModule()
- implementation(project(":core"))
+ useZygoteModule()
implementation(Dependencies.LibGDX.gdx)
implementation(Dependencies.LibGDX.Desktop.backend)
import com.badlogic.gdx.Files
import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application
import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration
-import ru.deadsoftware.cavedroid.CaveGame
+import ru.fredboy.cavedroid.zygote.CaveDroidApplication
internal object DesktopLauncher {
}
}
- val caveGame = CaveGame(
+ val caveGame = CaveDroidApplication(
gameDataDirectoryPath = System.getProperty("user.home") + "/.cavedroid",
isTouchScreen = touch,
isDebug = debug,
include("android")
include("desktop")
-include("core")
/**
* Global modules
