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