core/src/ru/deadsoftware/cavedroid/game/GameRenderer.java

   1 package ru.deadsoftware.cavedroid.game;
   2
   3 import com.badlogic.gdx.Gdx;
   4 import com.badlogic.gdx.graphics.GL20;
   5 import com.badlogic.gdx.math.Rectangle;
   6 import com.badlogic.gdx.utils.ObjectMap;
   7 import ru.deadsoftware.cavedroid.MainConfig;
   8 import ru.deadsoftware.cavedroid.game.input.IGameInputHandler;
   9 import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction;
  10 import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction;
  11 import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey;
  12 import ru.deadsoftware.cavedroid.game.input.handler.mouse.CursorMouseInputHandler;
  13 import ru.deadsoftware.cavedroid.game.input.mapper.KeyboardInputActionMapper;
  14 import ru.deadsoftware.cavedroid.game.input.mapper.MouseInputActionMapper;
  15 import ru.deadsoftware.cavedroid.game.mobs.MobsController;
  16 import ru.deadsoftware.cavedroid.game.mobs.player.Player;
  17 import ru.deadsoftware.cavedroid.game.objects.TouchButton;
  18 import ru.deadsoftware.cavedroid.game.render.IGameRenderer;
  19 import ru.deadsoftware.cavedroid.game.windows.GameWindowsManager;
  20 import ru.deadsoftware.cavedroid.misc.Assets;
  21 import ru.deadsoftware.cavedroid.misc.Renderer;
  22
  23 import javax.annotation.CheckForNull;
  24 import javax.inject.Inject;
  25 import java.util.ArrayList;
  26 import java.util.Comparator;
  27 import java.util.List;
  28 import java.util.Set;
  29
  30 @GameScope
  31 public class GameRenderer extends Renderer {
  32
  33     private static final TouchButton nullButton = new TouchButton(null, -1, true);
  34
  35     private final MainConfig mMainConfig;
  36     private final MobsController mMobsController;
  37     private final List<IGameRenderer> mRenderers;
  38     private final CursorMouseInputHandler mCursorMouseInputHandler;
  39     private final MouseInputActionMapper mMouseInputActionMapper;
  40     private final KeyboardInputActionMapper mKeyboardInputActionMapper;
  41     private final Set<IGameInputHandler<MouseInputAction>> mMouseInputHandlers;
  42     private final Set<IGameInputHandler<KeyboardInputAction>> mKeyboardInputHandlers;
  43     private final GameWindowsManager mGameWindowsManager;
  44
  45     @Inject
  46     GameRenderer(MainConfig mainConfig,
  47                  MobsController mobsController,
  48                  Set<IGameRenderer> renderers,
  49                  CursorMouseInputHandler cursorMouseInputHandler,
  50                  MouseInputActionMapper mouseInputActionMapper,
  51                  KeyboardInputActionMapper keyboardInputActionMapper,
  52                  Set<IGameInputHandler<MouseInputAction>> mouseInputHandlers,
  53                  Set<IGameInputHandler<KeyboardInputAction>> keyboardInputHandlers,
  54                  GameWindowsManager gameWindowsManager) {
  55         super(mainConfig.getWidth(), mainConfig.getHeight());
  56
  57         mMainConfig = mainConfig;
  58         mMobsController = mobsController;
  59         mRenderers = new ArrayList<>(renderers);
  60         mRenderers.sort(Comparator.comparingInt(IGameRenderer::getRenderLayer));
  61         mCursorMouseInputHandler = cursorMouseInputHandler;
  62         mMouseInputActionMapper = mouseInputActionMapper;
  63         mKeyboardInputActionMapper = keyboardInputActionMapper;
  64         mMouseInputHandlers = mouseInputHandlers;
  65         mKeyboardInputHandlers = keyboardInputHandlers;
  66         mGameWindowsManager = gameWindowsManager;
  67
  68         Gdx.gl.glClearColor(0f, .6f, .6f, 1f);
  69     }
  70
  71     private float mTouchDownX, mTouchDownY;
  72
  73     private void updateCameraPosition() {
  74         Player player = mMobsController.getPlayer();
  75         setCamPos(player.getX() + player.getWidth() / 2 - getWidth() / 2,
  76                 player.getY() + player.getHeight() / 2 - getHeight() / 2);
  77     }
  78
  79     private float transformScreenX(int screenX) {
  80         return getWidth() / Gdx.graphics.getWidth() * screenX;
  81     }
  82
  83     private float transformScreenY(int screenY) {
  84         return getHeight() / Gdx.graphics.getHeight() * screenY;
  85     }
  86
  87     private void handleMousePosition() {
  88         final Rectangle viewport = getCameraViewport();
  89         final MouseInputAction action = new MouseInputAction(
  90                 Gdx.input.getX() * (viewport.width / Gdx.graphics.getWidth()),
  91                 Gdx.input.getY() * (viewport.height / Gdx.graphics.getHeight()),
  92                 MouseInputActionKey.None.INSTANCE,
  93                 viewport);
  94
  95         mCursorMouseInputHandler.handle(action);
  96     }
  97
  98     private boolean handleMouseAction(@CheckForNull  MouseInputAction action) {
  99         if (action == null) {
 100             return false;
 101         }
 102
 103         boolean anyProcessed = false;
 104
 105         for (IGameInputHandler<MouseInputAction> handler : mMouseInputHandlers) {
 106             final boolean conditions = handler.checkConditions(action);
 107             if (conditions) {
 108                 anyProcessed = true;
 109                 handler.handle(action);
 110                 break;
 111             }
 112 //            anyProcessed = anyProcessed || conditions;
 113         }
 114         return anyProcessed;
 115     }
 116
 117     private boolean onMouseActionEvent(int mouseX, int mouseY, int button, boolean touchUp) {
 118         @CheckForNull MouseInputAction action = mMouseInputActionMapper
 119                 .map((float) mouseX, (float) mouseY, getCameraViewport(), button, touchUp);
 120         return handleMouseAction(action);
 121     }
 122
 123     @Override
 124     public boolean touchUp(int screenX, int screenY, int pointer, int button) {
 125         float touchX = transformScreenX(screenX);
 126         float touchY = transformScreenY(screenY);
 127
 128         if (mMainConfig.isTouch()) {
 129             TouchButton touchedKey = getTouchedKey(touchX, touchY);
 130             if (touchedKey.isMouse()) {
 131                 return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), true);
 132             } else {
 133                 return keyUp(touchedKey.getCode());
 134             }
 135         }
 136
 137         return onMouseActionEvent(screenX, screenY, button, true);
 138     }
 139
 140     private TouchButton getTouchedKey(float touchX, float touchY) {
 141         if (mGameWindowsManager.getCurrentWindowType() != GameUiWindow.NONE) {
 142             return nullButton;
 143         }
 144         for (ObjectMap.Entry<String, TouchButton> entry : Assets.guiMap) {
 145             TouchButton button = entry.value;
 146             if (button.getRect().contains(touchX, touchY)) {
 147                 return button;
 148             }
 149         }
 150         return nullButton;
 151     }
 152
 153     @Override
 154     public boolean touchDown(int screenX, int screenY, int pointer, int button) {
 155         float touchX = transformScreenX(screenX);
 156         float touchY = transformScreenY(screenY);
 157
 158         mTouchDownX = touchX;
 159         mTouchDownY = touchY;
 160
 161         if (mMainConfig.isTouch()) {
 162             TouchButton touchedKey = getTouchedKey(touchX, touchY);
 163             if (touchedKey.isMouse()) {
 164                 return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), false);
 165             } else {
 166                 return keyDown(touchedKey.getCode());
 167             }
 168         }
 169
 170         return onMouseActionEvent(screenX, screenY, button, false);
 171     }
 172
 173     @Override
 174     public boolean touchDragged(int screenX, int screenY, int pointer) {
 175         float touchX = transformScreenX(screenX);
 176         float touchY = transformScreenY(screenY);
 177
 178         if (Math.abs(touchX - mTouchDownX) < 16 && Math.abs(touchY - mTouchDownY) < 16) {
 179             return false;
 180         }
 181
 182         @CheckForNull MouseInputAction action =
 183                 mMouseInputActionMapper.mapDragged(screenX, screenY, getCameraViewport());
 184         return handleMouseAction(action);
 185     }
 186
 187     @Override
 188     public boolean scrolled(float amountX, float amountY) {
 189         @CheckForNull MouseInputAction action = mMouseInputActionMapper
 190                 .mapScrolled(Gdx.input.getX(), Gdx.input.getY(), amountX, amountY, getCameraViewport());
 191         return handleMouseAction(action);
 192     }
 193
 194     private boolean handleKeyboardAction(int keycode, boolean isKeyDown) {
 195         @CheckForNull final KeyboardInputAction action = mKeyboardInputActionMapper
 196                 .map(keycode, isKeyDown);
 197
 198         if (action == null) {
 199             return false;
 200         }
 201
 202         boolean anyProcessed = false;
 203
 204         for (IGameInputHandler<KeyboardInputAction> handler : mKeyboardInputHandlers) {
 205             final boolean conditions = handler.checkConditions(action);
 206             if (conditions) {
 207                 anyProcessed = true;
 208                 handler.handle(action);
 209                 break;
 210             }
 211         }
 212
 213         return anyProcessed;
 214     }
 215
 216     @Override
 217     public boolean keyDown(int keycode) {
 218         return handleKeyboardAction(keycode, true);
 219     }
 220
 221     @Override
 222     public boolean keyUp(int keycode) {
 223         return handleKeyboardAction(keycode, false);
 224     }
 225
 226     @Override
 227     public void render(float delta) {
 228         updateCameraPosition();
 229         handleMousePosition();
 230 //        mGameInput.moveCursor(this);
 231
 232         Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
 233
 234         spriter.begin();
 235         mRenderers.forEach(iGameRenderer -> iGameRenderer.draw(spriter, shaper, getCameraViewport(), delta));
 236         spriter.end();
 237     }
 238
 239 }