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 void updateCameraPosition() {
  66         Player player = mMobsController.getPlayer();
  67         setCamPos(player.getX() + player.getWidth() / 2 - getWidth() / 2,
  68                 player.getY() + player.getHeight() / 2 - getHeight() / 2);
  69     }
  70
  71     private float transformScreenX(int screenX) {
  72         return getWidth() / Gdx.graphics.getWidth() * screenX;
  73     }
  74
  75     private float transformScreenY(int screenY) {
  76         return getHeight() / Gdx.graphics.getHeight() * screenY;
  77     }
  78
  79     private void handleMousePosition() {
  80         final Rectangle viewport = getCameraViewport();
  81         final MouseInputAction action = new MouseInputAction(
  82                 Gdx.input.getX() * (viewport.width / Gdx.graphics.getWidth()),
  83                 Gdx.input.getY() * (viewport.height / Gdx.graphics.getHeight()),
  84                 MouseInputActionKey.None.INSTANCE,
  85                 viewport);
  86
  87         mCursorMouseInputHandler.handle(action);
  88     }
  89
  90     private boolean handleMouseAction(@CheckForNull  MouseInputAction action) {
  91         if (action == null) {
  92             return false;
  93         }
  94
  95         boolean anyProcessed = false;
  96
  97         for (IGameInputHandler<MouseInputAction> handler : mMouseInputHandlers) {
  98             final boolean conditions = handler.checkConditions(action);
  99             if (conditions) {
 100                 anyProcessed = true;
 101                 handler.handle(action);
 102                 break;
 103             }
 104 //            anyProcessed = anyProcessed || conditions;
 105         }
 106         return anyProcessed;
 107     }
 108
 109     private boolean onMouseActionEvent(int mouseX, int mouseY, int button, boolean touchUp) {
 110         @CheckForNull MouseInputAction action = mMouseInputActionMapper
 111                 .map((float) mouseX, (float) mouseY, getCameraViewport(), button, touchUp);
 112         return handleMouseAction(action);
 113     }
 114
 115     @Override
 116     public boolean touchUp(int screenX, int screenY, int pointer, int button) {
 117         float touchX = transformScreenX(screenX);
 118         float touchY = transformScreenY(screenY);
 119
 120         if (mMainConfig.isTouch()) {
 121             @CheckForNull TouchButton touchedKey = getTouchedKey(touchX, touchY);
 122             if (touchedKey != null && touchedKey.isMouse()) {
 123                 return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), true);
 124             } else if (touchedKey != null) {
 125                 return keyUp(touchedKey.getCode());
 126             }
 127         }
 128
 129         return onMouseActionEvent(screenX, screenY, button, true);
 130     }
 131
 132     @CheckForNull
 133     private TouchButton getTouchedKey(float touchX, float touchY) {
 134         for (ObjectMap.Entry<String, TouchButton> entry : Assets.guiMap) {
 135             TouchButton button = entry.value;
 136             if (button.getRect().contains(touchX, touchY)) {
 137                 return button;
 138             }
 139         }
 140         return null;
 141     }
 142
 143     @Override
 144     public boolean touchDown(int screenX, int screenY, int pointer, int button) {
 145         float touchX = transformScreenX(screenX);
 146         float touchY = transformScreenY(screenY);
 147
 148         if (mMainConfig.isTouch()) {
 149             @CheckForNull TouchButton touchedKey = getTouchedKey(touchX, touchY);
 150             if (touchedKey != null && touchedKey.isMouse()) {
 151                 return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), false);
 152             } else if (touchedKey != null) {
 153                 return keyDown(touchedKey.getCode());
 154             }
 155         }
 156
 157         return onMouseActionEvent(screenX, screenY, button, false);
 158     }
 159
 160     @Override
 161     public boolean touchDragged(int screenX, int screenY, int pointer) {
 162         @CheckForNull MouseInputAction action =
 163                 mMouseInputActionMapper.mapDragged(screenX, screenY, getCameraViewport());
 164         return handleMouseAction(action);
 165     }
 166
 167     @Override
 168     public boolean scrolled(float amountX, float amountY) {
 169         @CheckForNull MouseInputAction action = mMouseInputActionMapper
 170                 .mapScrolled(Gdx.input.getX(), Gdx.input.getY(), amountX, amountY, getCameraViewport());
 171         return handleMouseAction(action);
 172     }
 173
 174     private boolean handleKeyboardAction(int keycode, boolean isKeyDown) {
 175         @CheckForNull final KeyboardInputAction action = mKeyboardInputActionMapper
 176                 .map(keycode, isKeyDown);
 177
 178         if (action == null) {
 179             return false;
 180         }
 181
 182         boolean anyProcessed = false;
 183
 184         for (IGameInputHandler<KeyboardInputAction> handler : mKeyboardInputHandlers) {
 185             final boolean conditions = handler.checkConditions(action);
 186             if (conditions) {
 187                 anyProcessed = true;
 188                 handler.handle(action);
 189                 break;
 190             }
 191         }
 192
 193         return anyProcessed;
 194     }
 195
 196     @Override
 197     public boolean keyDown(int keycode) {
 198         return handleKeyboardAction(keycode, true);
 199     }
 200
 201     @Override
 202     public boolean keyUp(int keycode) {
 203         return handleKeyboardAction(keycode, false);
 204     }
 205
 206     @Override
 207     public void render(float delta) {
 208         updateCameraPosition();
 209         handleMousePosition();
 210 //        mGameInput.moveCursor(this);
 211
 212         Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
 213
 214         spriter.begin();
 215         mRenderers.forEach(iGameRenderer -> iGameRenderer.draw(spriter, shaper, getCameraViewport(), delta));
 216         spriter.end();
 217     }
 218
 219 }