dependencies {
useDagger()
+ useLibgdx()
useCommonModule()
useModule(":core:domain:configuration")
}
import dagger.Binds
import dagger.Module
-import ru.fredboy.cavedroid.data.configuration.repository.GameConfigurationRepositoryImpl
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.data.configuration.repository.GameContextRepositoryImpl
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
@Module
abstract class DataConfigurationModule {
@Binds
- internal abstract fun bindGameConfigurationRepository(impl: GameConfigurationRepositoryImpl): GameConfigurationRepository
+ internal abstract fun bindGameConfigurationRepository(impl: GameContextRepositoryImpl): GameContextRepository
}
\ No newline at end of file
+++ /dev/null
-package ru.fredboy.cavedroid.data.configuration.model
-
-import ru.fredboy.cavedroid.common.model.Joystick
-
-internal data class GameConfiguration(
- 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,
-)
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.model
+
+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
+}
+++ /dev/null
-package ru.fredboy.cavedroid.data.configuration.repository
-
-import ru.fredboy.cavedroid.common.model.Joystick
-import ru.fredboy.cavedroid.data.configuration.store.GameConfigurationStore
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class GameConfigurationRepositoryImpl @Inject constructor(
- private val gameConfigurationStore: GameConfigurationStore
-) : GameConfigurationRepository {
-
- override fun isTouch(): Boolean = gameConfigurationStore.isTouch
-
- override fun getGameDirectory(): String = gameConfigurationStore.gameDirectory
-
- override fun getWidth(): Float = gameConfigurationStore.width
-
- override fun getHeight(): Float = gameConfigurationStore.height
-
- override fun shouldShowInfo(): Boolean = gameConfigurationStore.showInfo
-
- override fun shouldShowMap(): Boolean = gameConfigurationStore.showMap
-
- override fun getJoystick(): Joystick? = gameConfigurationStore.joystick
-
- override fun isFullscreen(): Boolean = gameConfigurationStore.isFullscreen
-
- override fun useDynamicCamera(): Boolean = gameConfigurationStore.useDynamicCamera
-
- override fun setTouch(isTouch: Boolean) {
- gameConfigurationStore.isTouch = isTouch
- }
-
- override fun setGameDirectory(path: String) {
- gameConfigurationStore.gameDirectory = path
- }
-
- override fun setWidth(width: Float) {
- gameConfigurationStore.width = width
- }
-
- override fun setHeight(height: Float) {
- gameConfigurationStore.height = height
- }
-
- override fun setShowInfo(show: Boolean) {
- gameConfigurationStore.showInfo = show
- }
-
- override fun setShowMap(show: Boolean) {
- gameConfigurationStore.showMap = show
- }
-
- override fun setJoystick(joystick: Joystick?) {
- gameConfigurationStore.joystick = joystick
- }
-
- override fun setFullscreen(fullscreen: Boolean) {
- gameConfigurationStore.isFullscreen = fullscreen
- }
-
- override fun setUseDynamicCamera(use: Boolean) {
- gameConfigurationStore.useDynamicCamera = use
- }
-}
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.repository
+
+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
+
+@Singleton
+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 shouldShowInfo(): Boolean = gameContextStore.showInfo
+
+ override fun shouldShowMap(): Boolean = gameContextStore.showMap
+
+ 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 setShowInfo(show: Boolean) {
+ gameContextStore.showInfo = show
+ }
+
+ override fun setShowMap(show: Boolean) {
+ gameContextStore.showMap = show
+ }
+
+ override fun setJoystick(joystick: Joystick?) {
+ gameContextStore.joystick = joystick
+ }
+
+ override fun setFullscreen(fullscreen: Boolean) {
+ gameContextStore.isFullscreen = fullscreen
+ }
+
+ override fun setUseDynamicCamera(use: Boolean) {
+ gameContextStore.useDynamicCamera = use
+ }
+
+ override fun setCameraContext(cameraContext: CameraContext?) {
+ gameContextStore.cameraContext = cameraContext
+ }
+}
+++ /dev/null
-package ru.fredboy.cavedroid.data.configuration.store
-
-import ru.fredboy.cavedroid.common.model.Joystick
-import ru.fredboy.cavedroid.data.configuration.model.GameConfiguration
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class GameConfigurationStore @Inject constructor() {
-
- private val lock = Any()
-
- private val gameConfiguration = GameConfiguration()
-
- var isTouch: Boolean
- get() = synchronized(lock) { gameConfiguration.isTouch }
- set(value) = synchronized(lock) { gameConfiguration.isTouch = value }
-
- var gameDirectory: String
- get() = synchronized(lock) { gameConfiguration.gameDirectory }
- set(value) = synchronized(lock) { gameConfiguration.gameDirectory = value }
-
- var width: Float
- get() = synchronized(lock) { gameConfiguration.width }
- set(value) = synchronized(lock) { gameConfiguration.width = value }
-
- var height: Float
- get() = synchronized(lock) { gameConfiguration.height }
- set(value) = synchronized(lock) { gameConfiguration.height = value }
-
- var showInfo: Boolean
- get() = synchronized(lock) { gameConfiguration.showInfo }
- set(value) = synchronized(lock) { gameConfiguration.showInfo = value }
-
- var showMap: Boolean
- get() = synchronized(lock) { gameConfiguration.showMap }
- set(value) = synchronized(lock) { gameConfiguration.showMap = value }
-
- var joystick: Joystick?
- get() = synchronized(lock) { gameConfiguration.joystick }
- set(value) = synchronized(lock) { gameConfiguration.joystick = value }
-
- var isFullscreen: Boolean
- get() = synchronized(lock) { gameConfiguration.isFullscreen }
- set(value) = synchronized(lock) { gameConfiguration.isFullscreen = value }
-
- var useDynamicCamera: Boolean
- get() = synchronized(lock) { gameConfiguration.useDynamicCamera }
- set(value) = synchronized(lock) { gameConfiguration.useDynamicCamera = value }
-
- companion object {
- private const val TAG = "GameConfigurationStore"
- }
-}
--- /dev/null
+package ru.fredboy.cavedroid.data.configuration.store
+
+import com.badlogic.gdx.graphics.OrthographicCamera
+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() {
+
+ 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 }
+
+ var showInfo: Boolean
+ get() = synchronized(lock) { gameContext.showInfo }
+ set(value) = synchronized(lock) { gameContext.showInfo = value }
+
+ var showMap: Boolean
+ get() = synchronized(lock) { gameContext.showMap }
+ set(value) = synchronized(lock) { gameContext.showMap = value }
+
+ var joystick: Joystick?
+ 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 }
+
+ companion object {
+ private const val TAG = "GameConfigurationStore"
+ }
+}
java.targetCompatibility = ApplicationInfo.sourceCompatibility
dependencies {
+ useLibgdx()
useCommonModule()
}
--- /dev/null
+package ru.fredboy.cavedroid.domain.configuration.model
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.graphics.Camera
+import com.badlogic.gdx.math.Rectangle
+
+data class CameraContext(
+ val viewport: Rectangle,
+ val camera: Camera,
+) {
+
+ fun xOnViewport(x: Int) = viewport.width / Gdx.graphics.width * x.toFloat()
+
+ fun yOnViewport(y: Int) = viewport.height / Gdx.graphics.height * y.toFloat()
+
+ fun getViewportCoordinates(x: Int, y: Int): Pair<Float, Float> {
+ return xOnViewport(x) to yOnViewport(y)
+ }
+}
\ No newline at end of file
package ru.fredboy.cavedroid.domain.configuration.repository
import ru.fredboy.cavedroid.common.model.Joystick
+import ru.fredboy.cavedroid.domain.configuration.model.CameraContext
-interface GameConfigurationRepository {
+interface GameContextRepository {
fun isTouch(): Boolean
fun useDynamicCamera(): Boolean
+ fun getCameraContext(): CameraContext?
+
fun setTouch(isTouch: Boolean)
fun setGameDirectory(path: String)
fun setUseDynamicCamera(use: Boolean)
+ fun setCameraContext(cameraContext: CameraContext?)
+
}
import ru.deadsoftware.cavedroid.generated.module.*;
import ru.fredboy.cavedroid.common.api.GameController;
import ru.fredboy.cavedroid.common.di.GameScope;
-import ru.fredboy.cavedroid.data.configuration.di.DataConfigurationModule;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository;
+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;
ItemsRepository getItemsRepository();
- GameConfigurationRepository getGameConfigurationRepository();
+ GameContextRepository getGameConfigurationRepository();
GameController getGameController();
}
import dagger.Module;
import dagger.Provides;
-import ru.deadsoftware.cavedroid.MainConfig;
import ru.fredboy.cavedroid.common.di.GameScope;
import ru.fredboy.cavedroid.domain.assets.repository.MobAssetsRepository;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository;
+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;
@Provides
@GameScope
- public static DropController provideDropController(GameConfigurationRepository gameConfigurationRepository,
+ public static DropController provideDropController(GameContextRepository gameContextRepository,
SaveDataRepository saveDataRepository,
ItemsRepository itemsRepository,
DropWorldAdapter dropWorldAdapter) {
DropController controller = needLoad
- ? saveDataRepository.loadDropController(gameConfigurationRepository.getGameDirectory(), dropWorldAdapter)
+ ? saveDataRepository.loadDropController(gameContextRepository.getGameDirectory(), dropWorldAdapter)
: new DropController(itemsRepository, dropWorldAdapter);
return controller;
@Provides
@GameScope
- public static ContainerController provideFurnaceController(GameConfigurationRepository gameConfigurationRepository,
+ public static ContainerController provideFurnaceController(GameContextRepository gameContextRepository,
SaveDataRepository saveDataRepository,
GetItemByKeyUseCase getItemByKeyUseCase,
ContainerWorldAdapter containerWorldAdapter,
ContainerFactory containerFactory,
DropAdapter dropAdapter) {
ContainerController controller = needLoad
- ? saveDataRepository.loadContainerController(gameConfigurationRepository.getGameDirectory(), containerWorldAdapter, containerFactory, dropAdapter)
+ ? saveDataRepository.loadContainerController(gameContextRepository.getGameDirectory(), containerWorldAdapter, containerFactory, dropAdapter)
: new ContainerController(getItemByKeyUseCase, containerWorldAdapter, containerFactory, dropAdapter);
return controller;
@Provides
@GameScope
- public static MobController provideMobsController(GameConfigurationRepository gameConfigurationRepository,
+ public static MobController provideMobsController(GameContextRepository gameContextRepository,
SaveDataRepository saveDataRepository,
MobAssetsRepository mobAssetsRepository,
GetFallbackItemUseCase getFallbackItemUseCase,
MobWorldAdapter mobWorldAdapter) {
return needLoad
- ? saveDataRepository.loadMobController(gameConfigurationRepository.getGameDirectory(), mobWorldAdapter)
+ ? saveDataRepository.loadMobController(gameContextRepository.getGameDirectory(), mobWorldAdapter)
: new MobController(mobAssetsRepository, getFallbackItemUseCase, mobWorldAdapter);
}
@Provides
@GameScope
- public static GameWorld provideGameWorld(GameConfigurationRepository gameConfigurationRepository,
+ public static GameWorld provideGameWorld(GameContextRepository gameContextRepository,
SaveDataRepository saveDataRepository,
ItemsRepository itemsRepository) {
- final GameMapSaveData mapData = needLoad ? saveDataRepository.loadMap(gameConfigurationRepository.getGameDirectory()) : null;
+ final GameMapSaveData mapData = needLoad ? saveDataRepository.loadMap(gameContextRepository.getGameDirectory()) : null;
Block[][] fm = mapData != null ? mapData.retrieveForeMap() : null;
Block[][] bm = mapData != null ? mapData.retrieveBackMap() : null;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.utils.Disposable;
import com.badlogic.gdx.utils.Timer;
-import ru.deadsoftware.cavedroid.MainConfig;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository;
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
+import ru.fredboy.cavedroid.ux.controls.GameInputProcessor;
import ru.fredboy.cavedroid.ux.physics.GamePhysics;
import ru.fredboy.cavedroid.ux.physics.task.GameWorldBlocksLogicControllerTask;
import ru.fredboy.cavedroid.ux.physics.task.GameWorldFluidsLogicControllerTask;
private final GameWorldFluidsLogicControllerTask mGameWorldFluidsLogicControllerTask;
private final GameWorldBlocksLogicControllerTask mGameWorldBlocksLogicControllerTask;
private final GameWorldMobDamageControllerTask mGameWorldMobDamageControllerTask;
+ private final GameInputProcessor mGameInputProcessor;
private final Timer mWorldLogicTimer = new Timer();
@Inject
- public GameProc(GameConfigurationRepository gameConfigurationRepository,
+ public GameProc(GameContextRepository gameContextRepository,
GamePhysics gamePhysics,
GameRenderer gameRenderer,
MobController mobsController,
ContainerController containerController,
GameWorldFluidsLogicControllerTask gameWorldFluidsLogicControllerTask,
GameWorldBlocksLogicControllerTask gameWorldBlocksLogicControllerTask,
- GameWorldMobDamageControllerTask gameWorldMobDamageControllerTask
+ GameWorldMobDamageControllerTask gameWorldMobDamageControllerTask,
+ GameInputProcessor gameInputProcessor
) {
mGamePhysics = gamePhysics;
mGameRenderer = gameRenderer;
mGameWorldFluidsLogicControllerTask = gameWorldFluidsLogicControllerTask;
mGameWorldBlocksLogicControllerTask = gameWorldBlocksLogicControllerTask;
mGameWorldMobDamageControllerTask = gameWorldMobDamageControllerTask;
+ mGameInputProcessor = gameInputProcessor;
- mobsController.getPlayer().setControlMode(gameConfigurationRepository.isTouch() ? Player.ControlMode.WALK : Player.ControlMode.CURSOR);
+ mobsController.getPlayer().setControlMode(gameContextRepository.isTouch() ? Player.ControlMode.WALK : Player.ControlMode.CURSOR);
mWorldLogicTimer.scheduleTask(gameWorldFluidsLogicControllerTask, 0,
GameWorldFluidsLogicControllerTask.FLUID_UPDATE_INTERVAL_SEC);
public void update(float delta) {
mMobsController.update(delta);
mGamePhysics.update(delta);
+ mGameInputProcessor.update(delta);
mGameRenderer.render(delta);
mContainerController.update(delta);
}
public void show() {
- Gdx.input.setInputProcessor(mGameRenderer);
+ Gdx.input.setInputProcessor(mGameInputProcessor);
}
@Override
package ru.deadsoftware.cavedroid.game;
import com.badlogic.gdx.Gdx;
-import com.badlogic.gdx.Input;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
-import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.TimeUtils;
-import org.jetbrains.annotations.Nullable;
-import ru.deadsoftware.cavedroid.MainConfig;
-import ru.fredboy.cavedroid.common.model.Joystick;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository;
-import ru.fredboy.cavedroid.game.window.GameWindowType;
-import ru.fredboy.cavedroid.game.window.GameWindowsManager;
-import ru.fredboy.cavedroid.game.window.TooltipManager;
-import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler;
-import ru.fredboy.cavedroid.ux.controls.input.IMouseInputHandler;
-import ru.fredboy.cavedroid.ux.controls.input.action.KeyboardInputAction;
-import ru.fredboy.cavedroid.ux.controls.input.action.MouseInputAction;
-import ru.fredboy.cavedroid.ux.controls.input.action.keys.MouseInputActionKey;
-import ru.fredboy.cavedroid.ux.controls.input.handler.mouse.CursorMouseInputHandler;
-import ru.fredboy.cavedroid.ux.controls.input.mapper.KeyboardInputActionMapper;
-import ru.fredboy.cavedroid.ux.controls.input.mapper.MouseInputActionMapper;
-import ru.fredboy.cavedroid.ux.rendering.IGameRenderer;
import ru.deadsoftware.cavedroid.misc.Renderer;
import ru.fredboy.cavedroid.common.di.GameScope;
import ru.fredboy.cavedroid.common.utils.MeasureUnitsUtilsKt;
import ru.fredboy.cavedroid.common.utils.RenderingUtilsKt;
-import ru.fredboy.cavedroid.domain.assets.model.TouchButton;
import ru.fredboy.cavedroid.domain.assets.usecase.GetFontUseCase;
-import ru.fredboy.cavedroid.domain.assets.usecase.GetTouchButtonsUseCase;
+import ru.fredboy.cavedroid.domain.configuration.model.CameraContext;
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
import ru.fredboy.cavedroid.entity.mob.model.Player;
import ru.fredboy.cavedroid.game.controller.mob.MobController;
+import ru.fredboy.cavedroid.game.window.TooltipManager;
import ru.fredboy.cavedroid.game.world.GameWorld;
+import ru.fredboy.cavedroid.ux.rendering.IGameRenderer;
import javax.inject.Inject;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
@GameScope
public class GameRenderer extends Renderer {
private static final float CAMERA_SPEED = 72f;
private static final float MAX_CAM_DISTANCE_FROM_PLAYER = 64f;
- private static final float DRAG_THRESHOLD = 1f;
- private static final TouchButton nullButton = new TouchButton(new Rectangle(), -1, true);
-
- private final GameConfigurationRepository mGameConfigurationRepository;
+ private final GameContextRepository mGameContextRepository;
private final MobController mMobsController;
private final GameWorld mGameWorld;
private final List<IGameRenderer> mRenderers;
- private final CursorMouseInputHandler mCursorMouseInputHandler;
- private final MouseInputActionMapper mMouseInputActionMapper;
- private final KeyboardInputActionMapper mKeyboardInputActionMapper;
- private final Set<IMouseInputHandler> mMouseInputHandlers;
- private final Set<IKeyboardInputHandler> mKeyboardInputHandlers;
- private final GameWindowsManager mGameWindowsManager;
private final TooltipManager mTooltipManager;
private final GetFontUseCase mGetFontUseCase;
- private final GetTouchButtonsUseCase mGetTouchButtonsUseCase;
-
- private final TouchButton mouseLeftTouchButton, mouseRightTouchButton;
private final Vector2 mCamCenterToPlayer = new Vector2();
private long mCameraDelayMs = 0L;
@Inject
- GameRenderer(GameConfigurationRepository gameConfigurationRepository,
+ GameRenderer(GameContextRepository gameContextRepository,
MobController mobsController,
GameWorld gameWorld,
Set<IGameRenderer> renderers,
- CursorMouseInputHandler cursorMouseInputHandler,
- MouseInputActionMapper mouseInputActionMapper,
- KeyboardInputActionMapper keyboardInputActionMapper,
- Set<IMouseInputHandler> mouseInputHandlers,
- Set<IKeyboardInputHandler> keyboardInputHandlers,
- GameWindowsManager gameWindowsManager,
TooltipManager tooltipManager,
- GetFontUseCase getFontUseCase,
- GetTouchButtonsUseCase getTouchButtonsUseCase) {
- super(gameConfigurationRepository.getWidth(), gameConfigurationRepository.getHeight());
+ GetFontUseCase getFontUseCase) {
+ super(gameContextRepository.getWidth(), gameContextRepository.getHeight());
- mGameConfigurationRepository = gameConfigurationRepository;
+ mGameContextRepository = gameContextRepository;
mMobsController = mobsController;
mGameWorld = gameWorld;
mRenderers = new ArrayList<>(renderers);
return o1.getRenderLayer() - o2.getRenderLayer();
}
});
- mCursorMouseInputHandler = cursorMouseInputHandler;
- mMouseInputActionMapper = mouseInputActionMapper;
- mKeyboardInputActionMapper = keyboardInputActionMapper;
- mMouseInputHandlers = mouseInputHandlers;
- mKeyboardInputHandlers = keyboardInputHandlers;
- mGameWindowsManager = gameWindowsManager;
mTooltipManager = tooltipManager;
mGetFontUseCase = getFontUseCase;
- mGetTouchButtonsUseCase = getTouchButtonsUseCase;
-
- mouseLeftTouchButton = new TouchButton(new Rectangle(getWidth() / 2, 0f, getWidth() / 2, getHeight() / 2), Input.Buttons.LEFT, true);
- mouseRightTouchButton = new TouchButton(new Rectangle(getWidth() / 2, getHeight() / 2, getWidth() / 2, getHeight() / 2), Input.Buttons.RIGHT, true);
- mGameConfigurationRepository.setJoystick(new Joystick(mMobsController.getPlayer().getSpeed()));
+ mGameContextRepository.setCameraContext(new CameraContext(getCameraViewport(), getCamera()));
Gdx.gl.glClearColor(0f, .6f, .6f, 1f);
}
float camTargetX, camTargetY;
- boolean followPlayer = player.getControlMode() == Player.ControlMode.WALK || !mGameConfigurationRepository.isTouch();
+ boolean followPlayer = player.getControlMode() == Player.ControlMode.WALK || !mGameContextRepository.isTouch();
if (followPlayer) {
camTargetX = plTargetX + Math.min(player.getVelocity().x * 2, getWidth() / 2);
}
private void updateCameraPosition(float delta) {
- if (mGameConfigurationRepository.useDynamicCamera()) {
+ if (mGameContextRepository.useDynamicCamera()) {
updateDynamicCameraPosition(delta);
} else {
updateStaticCameraPosition();
}
private void handleMousePosition() {
- final Rectangle viewport = getCameraViewport();
-
final float screenX = transformScreenX(Gdx.input.getX());
final float screenY = transformScreenY(Gdx.input.getY());
- final MouseInputAction action = new MouseInputAction(
- screenX,
- screenY,
- MouseInputActionKey.None.INSTANCE,
- viewport);
-
- mCursorMouseInputHandler.handle(action);
-
if (!mTooltipManager.getCurrentMouseTooltip().isEmpty()) {
RenderingUtilsKt.drawString(spriter, mGetFontUseCase.invoke(),
mTooltipManager.getCurrentMouseTooltip(), screenX + 1, screenY + 1, Color.BLACK);
}
}
- private boolean handleMouseAction(@Nullable MouseInputAction action) {
- if (action == null) {
- return false;
- }
-
- boolean anyProcessed = false;
-
- for (IMouseInputHandler handler : mMouseInputHandlers) {
- final boolean conditions = handler.checkConditions(action);
- if (conditions) {
- anyProcessed = true;
- handler.handle(action);
- break;
- }
-// anyProcessed = anyProcessed || conditions;
- }
- return anyProcessed;
- }
-
- private boolean onMouseActionEvent(int mouseX, int mouseY, int button, boolean touchUp, int pointer) {
- @Nullable MouseInputAction action = mMouseInputActionMapper
- .map((float) mouseX, (float) mouseY, getCameraViewport(), button, touchUp, pointer);
- return handleMouseAction(action);
- }
-
- @Override
- public boolean touchUp(int screenX, int screenY, int pointer, int button) {
- float touchX = transformScreenX(screenX);
- float touchY = transformScreenY(screenY);
-
- final Joystick joy = mGameConfigurationRepository.getJoystick();
-
- if (mGameConfigurationRepository.isTouch()) {
- if (joy != null && joy.getActive() && joy.getPointer() == pointer) {
- return onMouseActionEvent(screenX, screenY, nullButton.getCode(), true, pointer);
- }
-
- TouchButton touchedKey = getTouchedKey(touchX, touchY);
- if (touchedKey.isMouse()) {
- return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), true, pointer);
- } else {
- return keyUp(touchedKey.getCode());
- }
- }
-
- return onMouseActionEvent(screenX, screenY, button, true, pointer);
- }
-
- private TouchButton getTouchedKey(float touchX, float touchY) {
- if (mGameWindowsManager.getCurrentWindowType() != GameWindowType.NONE) {
- return nullButton;
- }
- for (Map.Entry<String, TouchButton> entry : mGetTouchButtonsUseCase.invoke().entrySet()) {
- TouchButton button = entry.getValue();
- if (button.getRectangle().contains(touchX, touchY)) {
- return button;
- }
- }
-
- if (mouseLeftTouchButton.getRectangle().contains(touchX, touchY)) {
- return mouseLeftTouchButton;
- }
-
- if (mouseRightTouchButton.getRectangle().contains(touchX, touchY)) {
- return mouseRightTouchButton;
- }
-
- return nullButton;
- }
-
- @Override
- public boolean touchDown(int screenX, int screenY, int pointer, int button) {
- float touchX = transformScreenX(screenX);
- float touchY = transformScreenY(screenY);
-
- mTouchDownX = touchX;
- mTouchDownY = touchY;
-
- if (mGameConfigurationRepository.isTouch()) {
- TouchButton touchedKey = getTouchedKey(touchX, touchY);
- if (touchedKey.isMouse()) {
- return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), false, pointer);
- } else {
- return keyDown(touchedKey.getCode());
- }
- }
-
- return onMouseActionEvent(screenX, screenY, button, false, pointer);
- }
-
- @Override
- public boolean touchDragged(int screenX, int screenY, int pointer) {
- float touchX = transformScreenX(screenX);
- float touchY = transformScreenY(screenY);
-
- if (Math.abs(touchX - mTouchDownX) < 16 && Math.abs(touchY - mTouchDownY) < DRAG_THRESHOLD) {
- return false;
- }
-
- @Nullable MouseInputAction action =
- mMouseInputActionMapper.mapDragged(screenX, screenY, getCameraViewport(), pointer);
- return handleMouseAction(action);
- }
-
- @Override
- public boolean scrolled(float amountX, float amountY) {
- @Nullable MouseInputAction action = mMouseInputActionMapper
- .mapScrolled(Gdx.input.getX(), Gdx.input.getY(), amountX, amountY, getCameraViewport());
- return handleMouseAction(action);
- }
-
- private boolean handleKeyboardAction(int keycode, boolean isKeyDown) {
- @Nullable final KeyboardInputAction action = mKeyboardInputActionMapper
- .map(keycode, isKeyDown);
-
- if (action == null) {
- return false;
- }
-
- boolean anyProcessed = false;
-
- for (IKeyboardInputHandler handler : mKeyboardInputHandlers) {
- final boolean conditions = handler.checkConditions(action);
- if (conditions) {
- anyProcessed = true;
- handler.handle(action);
- break;
- }
- }
-
- return anyProcessed;
- }
-
- @Override
- public boolean keyDown(int keycode) {
- return handleKeyboardAction(keycode, true);
- }
-
- @Override
- public boolean keyUp(int keycode) {
- return handleKeyboardAction(keycode, false);
- }
-
@Override
public void render(float delta) {
updateCameraPosition(delta);
- if (mGameConfigurationRepository.getJoystick() != null && mGameConfigurationRepository.getJoystick().getActive()) {
- mGameConfigurationRepository.getJoystick().updateState(
- transformScreenX(Gdx.input.getX(mGameConfigurationRepository.getJoystick().getPointer())),
- transformScreenY(Gdx.input.getY(mGameConfigurationRepository.getJoystick().getPointer()))
+ if (mGameContextRepository.getJoystick() != null && mGameContextRepository.getJoystick().getActive()) {
+ mGameContextRepository.getJoystick().updateState(
+ transformScreenX(Gdx.input.getX(mGameContextRepository.getJoystick().getPointer())),
+ transformScreenY(Gdx.input.getY(mGameContextRepository.getJoystick().getPointer()))
);
}
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.GameConfigurationRepository;
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
import javax.inject.Inject;
private final MainConfig mMainConfig;
- private final GameConfigurationRepository mGameConfigurationRepository;
+ private final GameContextRepository mGameContextRepository;
private final MenuMain mMenuMain;
private final MenuNewGame mMenuNewGame;
@Inject
public MenuProc(
MainConfig mainConfig,
- GameConfigurationRepository gameConfigurationRepository,
+ GameContextRepository gameContextRepository,
MenusFactory menusFactory,
GetFontUseCase getFontUseCase,
GetStringWidthUseCase getStringWidthUseCase,
GetStringHeightUseCase getStringHeightUseCase,
GetTextureRegionByNameUseCase getTextureRegionByNameUseCase
) {
- super(gameConfigurationRepository.getWidth(), gameConfigurationRepository.getHeight());
+ super(gameContextRepository.getWidth(), gameContextRepository.getHeight());
mMainConfig = mainConfig;
- mGameConfigurationRepository = gameConfigurationRepository;
+ mGameContextRepository = gameContextRepository;
mGetFontUseCase = getFontUseCase;
mGetStringWidthUseCase = getStringWidthUseCase;
mGetStringHeightUseCase = getStringHeightUseCase;
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase;
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository;
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository;
import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository;
import java.util.HashMap;
private final SaveDataRepository mSaveDataRepository;
- private final GameConfigurationRepository mGameConfigurationRepository;
+ private final GameContextRepository mGameContextRepository;
public MenuMain(float width,
float height,
AssetLoader assetLoader,
GetTextureRegionByNameUseCase getTextureRegionByNameUseCase,
SaveDataRepository saveDataRepository,
- GameConfigurationRepository gameConfigurationRepository) {
+ GameContextRepository gameContextRepository) {
super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader, getTextureRegionByNameUseCase);
mSaveDataRepository = saveDataRepository;
- mGameConfigurationRepository = gameConfigurationRepository;
+ mGameContextRepository = gameContextRepository;
}
@Override
@Override
protected void initButtons() {
loadButtonsFromJson(mAssetLoader.getAssetHandle("json/menu_main_buttons.json"));
- if (mSaveDataRepository.exists(mGameConfigurationRepository.getGameDirectory())) {
+ if (mSaveDataRepository.exists(mGameContextRepository.getGameDirectory())) {
getButtons().get("load_game").setType(Button.NORMAL);
}
}
mCameraViewport.y = y;
}
+ public OrthographicCamera getCamera() {
+ return camera;
+ }
+
public Rectangle getCameraViewport() {
return mCameraViewport;
}
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
import ru.deadsoftware.cavedroid.prefs.PreferencesStore
import ru.fredboy.cavedroid.common.utils.ratio
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
class CaveGame(
private val gameDataDirectoryPath: String,
private val mainComponent: MainComponent
private val mainConfig: MainConfig
- private val gameConfigurationRepository: GameConfigurationRepository
+ private val mGameContextRepository: GameContextRepository
private val assetLoader: AssetLoader
mainConfig = mainComponent.mainConfig
assetLoader = mainComponent.assetLoader
- gameConfigurationRepository = mainComponent.gameConfigurationRepository
+ mGameContextRepository = mainComponent.gameContextRepository
}
private fun initMainConfig() {
mainConfig.mainComponent = mainComponent
- gameConfigurationRepository.apply {
+ mGameContextRepository.apply {
setGameDirectory(gameDataDirectoryPath)
setTouch(isTouchScreen)
setWidth(width)
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.GameConfigurationRepository
+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
val saveDataRepository: SaveDataRepository
- val gameConfigurationRepository: GameConfigurationRepository
+ val gameContextRepository: GameContextRepository
val gameController: GameController
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer
import ru.deadsoftware.cavedroid.misc.utils.AssetLoader
import ru.fredboy.cavedroid.domain.assets.usecase.GetTextureRegionByNameUseCase
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
import javax.inject.Inject
private val assetLoader: AssetLoader,
private val getTextureRegionByName: GetTextureRegionByNameUseCase,
private val saveDataRepository: SaveDataRepository,
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
) {
fun getMainMenu(
assetLoader,
getTextureRegionByName,
saveDataRepository,
- gameConfigurationRepository,
+ gameContextRepository,
).apply { init() }
}
--- /dev/null
+package ru.fredboy.cavedroid.ux.controls
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.Input
+import com.badlogic.gdx.InputProcessor
+import com.badlogic.gdx.math.Rectangle
+import ru.fredboy.cavedroid.common.di.GameScope
+import ru.fredboy.cavedroid.common.model.Joystick
+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.GameContextRepository
+import ru.fredboy.cavedroid.game.controller.mob.MobController
+import ru.fredboy.cavedroid.game.window.GameWindowType
+import ru.fredboy.cavedroid.game.window.GameWindowsManager
+import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
+import ru.fredboy.cavedroid.ux.controls.input.IMouseInputHandler
+import ru.fredboy.cavedroid.ux.controls.input.action.MouseInputAction
+import ru.fredboy.cavedroid.ux.controls.input.action.keys.MouseInputActionKey
+import ru.fredboy.cavedroid.ux.controls.input.handler.mouse.CursorMouseInputHandler
+import ru.fredboy.cavedroid.ux.controls.input.mapper.KeyboardInputActionMapper
+import ru.fredboy.cavedroid.ux.controls.input.mapper.MouseInputActionMapper
+import javax.inject.Inject
+import kotlin.math.abs
+
+@GameScope
+class GameInputProcessor @Inject constructor(
+ private val gameContextRepository: GameContextRepository,
+ private val mobController: MobController,
+ private val getTouchButtonsUseCase: GetTouchButtonsUseCase,
+ private val cursorMouseInputHandler: CursorMouseInputHandler,
+ private val mouseInputActionMapper: MouseInputActionMapper,
+ private val keyboardInputActionMapper: KeyboardInputActionMapper,
+ private val mouseInputHandlers: Set<@JvmSuppressWildcards IMouseInputHandler>,
+ private val keyboardInputHandlers: Set<@JvmSuppressWildcards IKeyboardInputHandler>,
+ private val gameWindowsManager: GameWindowsManager,
+) : InputProcessor {
+
+ private val mouseLeftTouchButton = TouchButton(
+ Rectangle(
+ /* x = */ gameContextRepository.getWidth() / 2,
+ /* y = */ 0f,
+ /* width = */ gameContextRepository.getWidth() / 2,
+ /* height = */ gameContextRepository.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
+ ),
+ Input.Buttons.RIGHT,
+ true
+ )
+
+ private var touchDownX = 0f
+ private var touchDownY = 0f
+
+ init {
+ gameContextRepository.setJoystick(Joystick(mobController.player.speed))
+ }
+
+ override fun keyDown(keycode: Int): Boolean {
+ return handleKeyboardAction(keycode, true)
+ }
+
+ override fun keyUp(keycode: Int): Boolean {
+ return handleKeyboardAction(keycode, false)
+ }
+
+ override fun keyTyped(p0: Char): Boolean {
+ return false;
+ }
+
+ override fun touchDown(screenX: Int, screenY: Int, pointer: Int, button: Int): Boolean {
+ val (touchX, touchY) = requireCameraContext().getViewportCoordinates(screenX, screenY)
+
+ touchDownX = touchX
+ touchDownY = touchY
+
+ if (gameContextRepository.isTouch()) {
+ val touchedKey = getTouchedKey(touchX, touchY)
+ return if (touchedKey.isMouse) {
+ onMouseActionEvent(
+ mouseX = screenX,
+ mouseY = screenY,
+ button = touchedKey.code,
+ touchUp = false,
+ pointer = pointer,
+ )
+ } else {
+ keyDown(touchedKey.code)
+ }
+ }
+
+ return onMouseActionEvent(screenX, screenY, button, false, pointer)
+ }
+
+ override fun touchUp(screenX: Int, screenY: Int, pointer: Int, button: Int): Boolean {
+ val (touchX, touchY) = requireCameraContext().getViewportCoordinates(screenX, screenY)
+
+ val joy: Joystick? = gameContextRepository.getJoystick()
+
+ if (gameContextRepository.isTouch()) {
+ if (joy != null && joy.active && joy.pointer == pointer) {
+ return onMouseActionEvent(
+ mouseX = screenX,
+ mouseY = screenY,
+ button = nullButton.code,
+ touchUp = true,
+ pointer = pointer,
+ )
+ }
+
+ val touchedKey: TouchButton = getTouchedKey(touchX, touchY)
+
+ return if (touchedKey.isMouse) {
+ onMouseActionEvent(
+ mouseX = screenX,
+ mouseY = screenY,
+ button = touchedKey.code,
+ touchUp = true,
+ pointer = pointer
+ )
+ } else {
+ keyUp(touchedKey.code)
+ }
+ }
+
+ return onMouseActionEvent(
+ mouseX = screenX,
+ mouseY = screenY,
+ button = button,
+ touchUp = true,
+ pointer = pointer,
+ )
+ }
+
+ override fun touchCancelled(p0: Int, p1: Int, p2: Int, p3: Int): Boolean {
+ return false
+ }
+
+ override fun touchDragged(screenX: Int, screenY: Int, pointer: Int): Boolean {
+ val (touchX, touchY) = requireCameraContext().getViewportCoordinates(screenX, screenY)
+
+ if (abs(touchX - touchDownX) < 16 && abs(touchY - touchDownY) < DRAG_THRESHOLD) {
+ return false
+ }
+
+ val action = mouseInputActionMapper.mapDragged(
+ mouseX = screenX.toFloat(),
+ mouseY = screenY.toFloat(),
+ cameraViewport = requireCameraContext().viewport,
+ pointer = pointer,
+ )
+
+ return handleMouseAction(action)
+ }
+
+ override fun mouseMoved(p0: Int, p1: Int): Boolean {
+ return false
+ }
+
+ override fun scrolled(amountX: Float, amountY: Float): Boolean {
+ val action: MouseInputAction? = mouseInputActionMapper
+ .mapScrolled(
+ mouseX = Gdx.input.x.toFloat(),
+ mouseY = Gdx.input.y.toFloat(),
+ amountX = amountX,
+ amountY = amountY,
+ cameraViewport = requireCameraContext().viewport,
+ )
+ return handleMouseAction(action)
+ }
+
+
+ fun update(delta: Float) {
+ handleMousePosition()
+ }
+
+ private fun getTouchedKey(touchX: Float, touchY: Float): TouchButton {
+ if (gameWindowsManager.currentWindowType != GameWindowType.NONE) {
+ return nullButton
+ }
+
+ for (entry in getTouchButtonsUseCase().entries) {
+ val button = entry.value
+ if (button.rectangle.contains(touchX, touchY)) {
+ return button
+ }
+ }
+
+ if (mouseLeftTouchButton.rectangle.contains(touchX, touchY)) {
+ return mouseLeftTouchButton
+ }
+
+ if (mouseRightTouchButton.rectangle.contains(touchX, touchY)) {
+ return mouseRightTouchButton
+ }
+
+ return nullButton
+ }
+
+ private fun handleMouseAction(action: MouseInputAction?): Boolean {
+ if (action == null) {
+ return false
+ }
+
+ var anyProcessed = false
+
+ for (handler in mouseInputHandlers) {
+ val conditions: Boolean = handler.checkConditions(action)
+ if (conditions) {
+ anyProcessed = true
+ handler.handle(action)
+ break
+ }
+ }
+
+ return anyProcessed
+ }
+
+ private fun handleKeyboardAction(keycode: Int, isKeyDown: Boolean): Boolean {
+ val action = keyboardInputActionMapper.map(keycode, isKeyDown)
+
+ if (action == null) {
+ return false
+ }
+
+ var anyProcessed = false
+
+ for (handler in keyboardInputHandlers) {
+ val conditions: Boolean = handler.checkConditions(action)
+ if (conditions) {
+ anyProcessed = true
+ handler.handle(action)
+ break
+ }
+ }
+
+ return anyProcessed
+ }
+
+ private fun onMouseActionEvent(mouseX: Int, mouseY: Int, button: Int, touchUp: Boolean, pointer: Int): Boolean {
+ val action: MouseInputAction? = mouseInputActionMapper.map(
+ mouseX = mouseX.toFloat(),
+ mouseY = mouseY.toFloat(),
+ cameraViewport = requireNotNull(gameContextRepository.getCameraContext()?.viewport),
+ button = button,
+ touchUp = touchUp,
+ pointer = pointer,
+ )
+ return handleMouseAction(action)
+ }
+
+ private fun handleMousePosition() {
+ val cameraContext = gameContextRepository.getCameraContext() ?: run {
+ Gdx.app.error(TAG, "CameraContext was not set")
+ return
+ }
+
+ val screenX = cameraContext.xOnViewport(Gdx.input.x)
+ val screenY = cameraContext.yOnViewport(Gdx.input.y)
+
+ val action = MouseInputAction(
+ screenX = screenX,
+ screenY = screenY,
+ actionKey = MouseInputActionKey.None,
+ cameraViewport = cameraContext.viewport,
+ )
+
+ cursorMouseInputHandler.handle(action)
+ }
+
+ private fun requireCameraContext(): CameraContext {
+ return requireNotNull(gameContextRepository.getCameraContext()) { "CameraContext was not set" }
+ }
+
+ companion object {
+ private const val TAG = "GameInputProcessor"
+
+ private const val DRAG_THRESHOLD = 1f
+
+ private val nullButton = TouchButton(Rectangle(), -1, true)
+ }
+}
\ No newline at end of file
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
import ru.fredboy.cavedroid.common.di.GameScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class FlyDownKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
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 || !gameConfigurationRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class FlyUpKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
return action.actionKey is KeyboardInputActionKey.Up &&
!mobController.player.swim &&
mobController.player.isFlyMode &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameConfigurationRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
@GameScope
@BindKeyboardInputHandler
class GoLeftKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
- val isTouch = gameConfigurationRepository.isTouch()
+ val isTouch = gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
@GameScope
@BindKeyboardInputHandler
class GoRightKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.Right &&
- (mobController.player.controlMode == Player.ControlMode.WALK || !gameConfigurationRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class JumpKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
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 || !gameConfigurationRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class MoveCursorControlsModeKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobsController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
- return gameConfigurationRepository.isTouch() &&
+ return gameContextRepository.isTouch() &&
mobsController.player.controlMode == Player.ControlMode.CURSOR && action.isKeyDown &&
(action.actionKey is KeyboardInputActionKey.Left ||
action.actionKey is KeyboardInputActionKey.Right ||
import ru.fredboy.cavedroid.common.api.GameController
import ru.fredboy.cavedroid.common.di.GameScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.save.repository.SaveDataRepository
import ru.fredboy.cavedroid.game.controller.container.ContainerController
import ru.fredboy.cavedroid.game.controller.drop.DropController
@GameScope
@BindKeyboardInputHandler
class PauseGameKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val gameController: GameController,
private val dropController: DropController,
private val mobController: MobController,
}
saveDataRepository.save(
- gameDataFolder = gameConfigurationRepository.getGameDirectory(),
+ gameDataFolder = gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class StopSwimKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
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 || !gameConfigurationRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.world.GameWorld
@GameScope
@BindKeyboardInputHandler
class SwimUpKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
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 || !gameConfigurationRepository.isTouch())
+ (mobController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class ToggleControlsModeKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
return action.actionKey is KeyboardInputActionKey.SwitchControlsMode && !action.isKeyDown
- && gameConfigurationRepository.isTouch()
+ && gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
import ru.fredboy.cavedroid.ux.controls.input.action.KeyboardInputAction
import ru.fredboy.cavedroid.ux.controls.input.action.keys.KeyboardInputActionKey
@GameScope
@BindKeyboardInputHandler
class ToggleDebugInfoKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
}
override fun handle(action: KeyboardInputAction) {
- gameConfigurationRepository.setShowInfo(!gameConfigurationRepository.shouldShowInfo())
+ gameContextRepository.setShowInfo(!gameContextRepository.shouldShowInfo())
}
}
\ No newline at end of file
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
import ru.fredboy.cavedroid.common.di.GameScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
import ru.fredboy.cavedroid.ux.controls.input.action.KeyboardInputAction
import ru.fredboy.cavedroid.ux.controls.input.action.keys.KeyboardInputActionKey
@GameScope
@BindKeyboardInputHandler
class ToggleMinimapKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
) : IKeyboardInputHandler {
override fun checkConditions(action: KeyboardInputAction): Boolean {
}
override fun handle(action: KeyboardInputAction) {
- gameConfigurationRepository.setShowMap(!gameConfigurationRepository.shouldShowMap())
+ gameContextRepository.setShowMap(!gameContextRepository.shouldShowMap())
}
}
\ No newline at end of file
package ru.fredboy.cavedroid.ux.controls.input.handler.keyboard
import ru.fredboy.cavedroid.common.di.GameScope
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.ux.controls.input.IKeyboardInputHandler
@GameScope
@BindKeyboardInputHandler
class TurnOnFlyModeKeyboardInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
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 || !gameConfigurationRepository.isTouch())
+ (mobsController.player.controlMode == Player.ControlMode.WALK || !gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.items.repository.ItemsRepository
import ru.fredboy.cavedroid.game.window.GameWindowType
import ru.fredboy.cavedroid.game.window.GameWindowsManager
@GameScope
@BindMouseInputHandler
class CreativeInventoryScrollMouseInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val gameWindowsManager: GameWindowsManager,
private val itemsRepository: ItemsRepository,
private val textureRegions: GetTextureRegionByNameUseCase,
}
private fun checkDragConditions(action: MouseInputAction): Boolean {
- return gameConfigurationRepository.isTouch() && action.actionKey is MouseInputActionKey.Dragged &&
+ return gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.items.model.block.Block
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByIndexUseCase
import ru.fredboy.cavedroid.entity.mob.model.Direction
@GameScope
@BindMouseInputHandler
class CursorMouseInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
private val gameWorld: GameWorld,
private val gameWindowsManager: GameWindowsManager,
val pastCursorY = player.cursorY
when {
- player.controlMode == Player.ControlMode.WALK && gameConfigurationRepository.isTouch() -> handleWalkTouch()
- !gameConfigurationRepository.isTouch() -> handleMouse(action)
+ player.controlMode == Player.ControlMode.WALK && gameContextRepository.isTouch() -> handleWalkTouch()
+ !gameContextRepository.isTouch() -> handleMouse(action)
}
mobController.checkPlayerCursorBounds()
- if (player.controlMode == Player.ControlMode.WALK && gameConfigurationRepository.isTouch()) {
+ if (player.controlMode == Player.ControlMode.WALK && gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
@GameScope
@BindMouseInputHandler
class JoystickInputHandler @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val gameWorld: GameWorld,
override fun checkConditions(action: MouseInputAction): Boolean {
return gameWindowsManager.currentWindowType == GameWindowType.NONE &&
- gameConfigurationRepository.isTouch() &&
+ gameContextRepository.isTouch() &&
// mobsController.player.controlMode == Player.ControlMode.WALK &&
- gameConfigurationRepository.getJoystick() != null &&
+ gameContextRepository.getJoystick() != null &&
(action.actionKey is MouseInputActionKey.Touch) &&
- (action.actionKey.pointer == gameConfigurationRepository.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
- gameConfigurationRepository.getJoystick()?.activate(action.screenX, action.screenY, key.pointer) ?: return
+ gameContextRepository.getJoystick()?.activate(action.screenX, action.screenY, key.pointer) ?: return
active = true
}
private fun handleTouchUp(action: MouseInputAction) {
- gameConfigurationRepository.getJoystick()?.deactivate()
+ gameContextRepository.getJoystick()?.deactivate()
active = false
}
private fun handleCursor() {
- val joystick = gameConfigurationRepository.getJoystick() ?: return
+ val joystick = gameContextRepository.getJoystick() ?: return
if (TimeUtils.timeSinceMillis(cursorTimeoutMs) < 150L) {
return
return
}
- val joystick = gameConfigurationRepository.getJoystick() ?: return
+ val joystick = gameContextRepository.getJoystick() ?: return
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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.ux.controls.input.action.MouseInputAction
import ru.fredboy.cavedroid.ux.controls.input.action.keys.MouseInputActionKey
import javax.inject.Inject
@GameScope
class MouseInputActionMapper @Inject constructor(
- val gameConfigurationRepository: GameConfigurationRepository,
+ val gameContextRepository: GameContextRepository,
) {
fun map(
}
private fun getScreenX(mouseX: Float): Float {
- return mouseX * (gameConfigurationRepository.getWidth() / Gdx.graphics.width)
+ return mouseX * (gameContextRepository.getWidth() / Gdx.graphics.width)
}
private fun getScreenY(mouseY: Float): Float {
- return mouseY * (gameConfigurationRepository.getHeight() / Gdx.graphics.height)
+ return mouseY * (gameContextRepository.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.GameConfigurationRepository;
+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;
import ru.fredboy.cavedroid.domain.items.usecase.GetItemByKeyUseCase;
private final Vector2 gravity = new Vector2(0, 444.44f);
private final GameWorld mGameWorld;
- private final GameConfigurationRepository mGameConfigurationRepository;
+ private final GameContextRepository mGameContextRepository;
private final MobController mMobController;
private final DropController mDropController;
private final GetItemByKeyUseCase mGetItemByKeyUseCase;
@Inject
public GamePhysics(GameWorld gameWorld,
- GameConfigurationRepository gameConfigurationRepository,
+ GameContextRepository gameContextRepository,
MobController mobController,
DropController dropController,
GetItemByKeyUseCase getItemByKeyUseCase) {
mGameWorld = gameWorld;
- mGameConfigurationRepository = gameConfigurationRepository;
+ mGameContextRepository = gameContextRepository;
mMobController = mobController;
mDropController = dropController;
mGetItemByKeyUseCase = getItemByKeyUseCase;
}
if (getBlock(player).isFluid()) {
- if (mGameConfigurationRepository.isTouch() && player.getVelocity().x != 0 && !player.getSwim() && !player.isFlyMode()) {
+ if (mGameContextRepository.isTouch() && player.getVelocity().x != 0 && !player.getSwim() && !player.isFlyMode()) {
player.setSwim(true);
}
if (!player.getSwim()) {
mobXColl(player);
- if (mGameConfigurationRepository.isTouch() && !player.isFlyMode() && player.getCanJump() && player.getVelocity().x != 0 && checkJump(player)) {
+ if (mGameContextRepository.isTouch() && !player.isFlyMode() && player.getCanJump() && player.getVelocity().x != 0 && checkJump(player)) {
player.jump();
player.setCanJump(false);
}
import ru.fredboy.cavedroid.common.utils.drawString
import ru.fredboy.cavedroid.common.utils.forEachBlockInArea
import ru.fredboy.cavedroid.common.utils.px
-import ru.fredboy.cavedroid.domain.configuration.repository.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.domain.items.model.block.Block
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.world.GameWorld
@GameScope
@BindRenderer
class DebugRenderer @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val gameWorld: GameWorld,
private val mobController: MobController,
private val debugInfoStringsProvider: DebugInfoStringsProvider,
}
override fun draw(spriteBatch: SpriteBatch, shapeRenderer: ShapeRenderer, viewport: Rectangle, delta: Float) {
- if (gameConfigurationRepository.shouldShowInfo()) {
+ if (gameContextRepository.shouldShowInfo()) {
drawDebugInfo(spriteBatch)
}
- if (gameConfigurationRepository.shouldShowMap()) {
+ if (gameContextRepository.shouldShowMap()) {
drawMinimap(
spriteBatch = spriteBatch,
shapeRenderer = shapeRenderer,
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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Player
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.window.GameWindowType
@GameScope
@BindRenderer
class TouchControlsRenderer @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
private val mobController: MobController,
private val gameWindowsManager: GameWindowsManager,
private val textureRegions: GetTextureRegionByNameUseCase,
private val joyStick = Sprite(textureRegions["joy_stick"])
private fun drawJoystick(spriteBatch: SpriteBatch) {
- val joystick = gameConfigurationRepository.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 (!gameConfigurationRepository.isTouch() || gameWindowsManager.currentWindowType != GameWindowType.NONE) {
+ if (!gameContextRepository.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.GameConfigurationRepository
+import ru.fredboy.cavedroid.domain.configuration.repository.GameContextRepository
import ru.fredboy.cavedroid.entity.mob.model.Direction
import ru.fredboy.cavedroid.game.controller.mob.MobController
import ru.fredboy.cavedroid.game.window.GameWindowsConfigs
@GameScope
class SurvivalWindowRenderer @Inject constructor(
- private val gameConfigurationRepository: GameConfigurationRepository,
+ private val gameContextRepository: GameContextRepository,
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 (gameConfigurationRepository.isTouch()) {
+ if (gameContextRepository.isTouch()) {
return
}
- val mouseX = Gdx.input.x * (gameConfigurationRepository.getWidth() / Gdx.graphics.width)
- val mouseY = Gdx.input.y * (gameConfigurationRepository.getHeight() / Gdx.graphics.height)
+ val mouseX = Gdx.input.x * (gameContextRepository.getWidth() / Gdx.graphics.width)
+ val mouseY = Gdx.input.y * (gameContextRepository.getHeight() / Gdx.graphics.height)
val h = mouseX.toDouble() - portraitX.toDouble()
val v = mouseY.toDouble() - portraitY.toDouble()
