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