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