X-Git-Url: https://deadsoftware.ru/gitweb?a=blobdiff_plain;f=core%2Fsrc%2Fru%2Fdeadsoftware%2Fcavedroid%2Fgame%2FGameRenderer.java;h=b54bead932f38f903a7f829cf88b5c1a60d73088;hb=cf4113d5bfd3fca7c3815bf14a214eebd822216c;hp=43973bcea0116f9713baff4de5182ec39aa09fe2;hpb=121928e90bdfa3a9d9c8bd708b9f8da28d3807c0;p=cavedroid.git

diff --git a/core/src/ru/deadsoftware/cavedroid/game/GameRenderer.java b/core/src/ru/deadsoftware/cavedroid/game/GameRenderer.java
index 43973bc..b54bead 100644
--- a/core/src/ru/deadsoftware/cavedroid/game/GameRenderer.java
+++ b/core/src/ru/deadsoftware/cavedroid/game/GameRenderer.java
@@ -1,401 +1,219 @@
 package ru.deadsoftware.cavedroid.game;
 
 import com.badlogic.gdx.Gdx;
-import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.GL20;
-import com.badlogic.gdx.graphics.g2d.Sprite;
-import com.badlogic.gdx.graphics.g2d.TextureRegion;
-import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
-import com.badlogic.gdx.math.Intersector;
-import com.badlogic.gdx.math.MathUtils;
 import com.badlogic.gdx.math.Rectangle;
-import kotlin.collections.CollectionsKt;
+import com.badlogic.gdx.utils.ObjectMap;
 import ru.deadsoftware.cavedroid.MainConfig;
-import ru.deadsoftware.cavedroid.game.mobs.Mob;
+import ru.deadsoftware.cavedroid.game.input.IGameInputHandler;
+import ru.deadsoftware.cavedroid.game.input.action.KeyboardInputAction;
+import ru.deadsoftware.cavedroid.game.input.action.MouseInputAction;
+import ru.deadsoftware.cavedroid.game.input.action.keys.MouseInputActionKey;
+import ru.deadsoftware.cavedroid.game.input.handler.mouse.CursorMouseInputHandler;
+import ru.deadsoftware.cavedroid.game.input.mapper.KeyboardInputActionMapper;
+import ru.deadsoftware.cavedroid.game.input.mapper.MouseInputActionMapper;
 import ru.deadsoftware.cavedroid.game.mobs.MobsController;
 import ru.deadsoftware.cavedroid.game.mobs.Player;
-import ru.deadsoftware.cavedroid.game.model.block.Block;
-import ru.deadsoftware.cavedroid.game.model.item.Item;
-import ru.deadsoftware.cavedroid.game.objects.Drop;
-import ru.deadsoftware.cavedroid.game.objects.DropController;
-import ru.deadsoftware.cavedroid.game.world.GameWorld;
-import ru.deadsoftware.cavedroid.misc.ControlMode;
+import ru.deadsoftware.cavedroid.game.objects.TouchButton;
+import ru.deadsoftware.cavedroid.game.render.IGameRenderer;
+import ru.deadsoftware.cavedroid.misc.Assets;
 import ru.deadsoftware.cavedroid.misc.Renderer;
 
 import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
 import javax.inject.Inject;
-
-import java.util.Collection;
-
-import static ru.deadsoftware.cavedroid.misc.Assets.*;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
 
 @GameScope
 public class GameRenderer extends Renderer {
 
-    private static final String TAG = "GameRenderer";
-
     private final MainConfig mMainConfig;
-    private final GameInput mGameInput;
-    private final GameWorld mGameWorld;
     private final MobsController mMobsController;
-    private final DropController mDropController;
-    private final GameItemsHolder mGameItemsHolder;
+    private final List<IGameRenderer> mRenderers;
+    private final CursorMouseInputHandler mCursorMouseInputHandler;
+    private final MouseInputActionMapper mMouseInputActionMapper;
+    private final KeyboardInputActionMapper mKeyboardInputActionMapper;
+    private final Set<IGameInputHandler<MouseInputAction>> mMouseInputHandlers;
+    private final Set<IGameInputHandler<KeyboardInputAction>> mKeyboardInputHandlers;
 
     @Inject
     GameRenderer(MainConfig mainConfig,
-                 GameInput gameInput,
-                 GameWorld gameWorld,
                  MobsController mobsController,
-                 DropController dropController,
-                 GameItemsHolder gameItemsHolder) {
+                 Set<IGameRenderer> renderers,
+                 CursorMouseInputHandler cursorMouseInputHandler,
+                 MouseInputActionMapper mouseInputActionMapper,
+                 KeyboardInputActionMapper keyboardInputActionMapper,
+                 Set<IGameInputHandler<MouseInputAction>> mouseInputHandlers,
+                 Set<IGameInputHandler<KeyboardInputAction>> keyboardInputHandlers) {
         super(mainConfig.getWidth(), mainConfig.getHeight());
 
         mMainConfig = mainConfig;
-        mGameInput = gameInput;
-        mGameWorld = gameWorld;
         mMobsController = mobsController;
-        mDropController = dropController;
-        mGameItemsHolder = gameItemsHolder;
+        mRenderers = new ArrayList<>(renderers);
+        mRenderers.sort(Comparator.comparingInt(IGameRenderer::getRenderLayer));
+        mCursorMouseInputHandler = cursorMouseInputHandler;
+        mMouseInputActionMapper = mouseInputActionMapper;
+        mKeyboardInputActionMapper = keyboardInputActionMapper;
+        mMouseInputHandlers = mouseInputHandlers;
+        mKeyboardInputHandlers = keyboardInputHandlers;
 
         Gdx.gl.glClearColor(0f, .6f, .6f, 1f);
     }
 
-    private float drawX(int x) {
-        return x * 16 - getCamX();
-    }
-
-    private float drawY(int y) {
-        return y * 16 - getCamY();
+    private void updateCameraPosition() {
+        Player player = mMobsController.getPlayer();
+        setCamPos(player.getX() + player.getWidth() / 2 - getWidth() / 2,
+                player.getY() + player.getHeight() / 2 - getHeight() / 2);
     }
 
-    private void drawWreck(Block bl) {
-        if (mGameInput.getBlockDamage() > 0) {
-            int index = 10 * mGameInput.getBlockDamage() / bl.getHp();
-            String key = "break_" + index;
-
-            if (index > 10 || index < 0) {
-                return;
-            }
-
-            spriter.draw(textureRegions.get(key), mGameInput.getCurX() * 16 - getCamX(),
-                    mGameInput.getCurY() * 16 - getCamY());
-        }
+    private float transformScreenX(int screenX) {
+        return getWidth() / Gdx.graphics.getWidth() * screenX;
     }
 
-    private void drawBlock(int x, int y, boolean drawBG) {
-        if (drawBG) {
-            if ((!mGameWorld.hasForeAt(x, y) || mGameWorld.getForeMap(x, y).isTransparent())
-                    && mGameWorld.hasBackAt(x, y)) {
-                mGameWorld.getBackMap(x, y).draw(spriter, drawX(x), drawY(y));
-                if (!mGameWorld.hasForeAt(x, y) && x == mGameInput.getCurX() && y == mGameInput.getCurY()) {
-                    drawWreck(mGameWorld.getBackMap(mGameInput.getCurX(), mGameInput.getCurY()));
-                }
-            }
-        }
-        if (mGameWorld.hasForeAt(x, y) && mGameWorld.getForeMap(x, y).isBackground() == drawBG) {
-            mGameWorld.getForeMap(x, y).draw(spriter, drawX(x), drawY(y));
-            if (x == mGameInput.getCurX() && y == mGameInput.getCurY()) {
-                drawWreck(mGameWorld.getForeMap(mGameInput.getCurX(), mGameInput.getCurY()));
-            }
-        }
+    private float transformScreenY(int screenY) {
+        return getHeight() / Gdx.graphics.getHeight() * screenY;
     }
 
-    private void drawWorld(boolean bg) {
-        int minX = (int) (getCamX() / 16) - 1;
-        int minY = (int) (getCamY() / 16) - 1;
-        int maxX = (int) ((getCamX() + getWidth()) / 16) + 1;
-        int maxY = (int) ((getCamY() + getHeight()) / 16) + 1;
-        if (minY < 0) {
-            minY = 0;
-        }
-        if (maxY > mGameWorld.getHeight()) {
-            maxY = mGameWorld.getHeight();
-        }
-        for (int y = minY; y < maxY; y++) {
-            for (int x = minX; x < maxX; x++) {
-                drawBlock(x, y, bg);
-            }
-        }
-        if (bg) {
-            spriter.end();
-            Gdx.gl.glEnable(GL20.GL_BLEND);
-            Gdx.gl.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
-            shaper.begin(ShapeRenderer.ShapeType.Filled);
-            shaper.setColor(0f, 0f, 0f, .5f);
-            for (int y = minY; y < maxY; y++) {
-                for (int x = minX; x < maxX; x++) {
-                    if ((!mGameWorld.hasForeAt(x, y) || mGameWorld.getForeMap(x, y).isTransparent())
-                            && mGameWorld.hasBackAt(x, y)) {
-                        shaper.rect(drawX(x), drawY(y), 16, 16);
-                    }
-                }
-            }
-            shaper.end();
-            Gdx.gl.glDisable(GL20.GL_BLEND);
-            spriter.begin();
-        }
-    }
+    private void handleMousePosition() {
+        final Rectangle viewport = getCameraViewport();
+        final MouseInputAction action = new MouseInputAction(
+                Gdx.input.getX() * (viewport.width / Gdx.graphics.getWidth()),
+                Gdx.input.getY() * (viewport.height / Gdx.graphics.getHeight()),
+                MouseInputActionKey.None.INSTANCE,
+                viewport);
 
-    private Rectangle getShiftedRectRespectfulToViewPort(final Rectangle rect, final float shift) {
-        return new Rectangle(rect.x + shift - getCamX(), rect.y - getCamY(), rect.width, rect.height);
+        mCursorMouseInputHandler.handle(action);
     }
 
-    @CheckForNull
-    private Rectangle getDrawingRectIfInsideViewport(final Rectangle rectangle) {
-        final Rectangle viewportRect = new Rectangle(0, 0, getWidth(), getHeight());
-
-        final Rectangle notShifted = getShiftedRectRespectfulToViewPort(rectangle, 0);
-        if (Intersector.overlaps(viewportRect, notShifted)) {
-            return notShifted;
+    private boolean handleMouseAction(@CheckForNull  MouseInputAction action) {
+        if (action == null) {
+            return false;
         }
 
-        final Rectangle shiftedLeft = getShiftedRectRespectfulToViewPort(rectangle, -mGameWorld.getWidthPx());
-        if (Intersector.overlaps(viewportRect, shiftedLeft)) {
-            return shiftedLeft;
-        }
+        boolean anyProcessed = false;
 
-        final Rectangle shiftedRight = getShiftedRectRespectfulToViewPort(rectangle, mGameWorld.getWidthPx());
-        if (Intersector.overlaps(viewportRect, shiftedRight)) {
-            return shiftedRight;
+        for (IGameInputHandler<MouseInputAction> handler : mMouseInputHandlers) {
+            final boolean conditions = handler.checkConditions(action);
+            if (conditions) {
+                anyProcessed = true;
+                handler.handle(action);
+                break;
+            }
+//            anyProcessed = anyProcessed || conditions;
         }
-
-        return null;
+        return anyProcessed;
     }
 
-    private void drawMob(Mob mob, float delta) {
-        float mobDrawX = mob.getX() - getCamX();
-        float mobDrawY = mob.getY() - getCamY();
-
-        if (mobDrawX + mob.getWidth() < 0 && mobDrawX + mGameWorld.getWidthPx() > 0) {
-            mobDrawX += mGameWorld.getWidthPx();
-        } else if (mobDrawX > getWidth() && mobDrawX + mob.getWidth() - mGameWorld.getWidthPx() > 0) {
-            mobDrawX -= mGameWorld.getWidthPx();
-        } else if (mobDrawX + mob.getWidth() < 0 && mobDrawX > getWidth()) {
-            return;
-        }
-
-        mob.draw(spriter, mobDrawX, mobDrawY, delta);
+    private boolean onMouseActionEvent(int mouseX, int mouseY, int button, boolean touchUp) {
+        @CheckForNull MouseInputAction action = mMouseInputActionMapper
+                .map((float) mouseX, (float) mouseY, getCameraViewport(), button, touchUp);
+        return handleMouseAction(action);
     }
 
-    private void drawDrop(Drop drop) {
-        @CheckForNull final Rectangle drawingRect = getDrawingRectIfInsideViewport(drop);
-
-        if (drawingRect == null) {
-            return;
-        }
-
-        final Sprite sprite = drop.getItem().getSprite();
-
-        sprite.setPosition(drawingRect.x, drawingRect.y);
-        sprite.setSize(drawingRect.width, drawingRect.height);
-        sprite.draw(spriter);
-    }
+    @Override
+    public boolean touchUp(int screenX, int screenY, int pointer, int button) {
+        float touchX = transformScreenX(screenX);
+        float touchY = transformScreenY(screenY);
 
-    @SuppressWarnings("IntegerDivisionInFloatingPointContext")
-    private void drawCreative() {
-        TextureRegion creative = textureRegions.get("creative");
-        float x = getWidth() / 2 - (float) creative.getRegionWidth() / 2;
-        float y = getHeight() / 2 - (float) creative.getRegionHeight() / 2;
-        spriter.draw(creative, x, y);
-        spriter.draw(textureRegions.get("handle"), x + 156,
-                y + 18 + (mGameInput.getCreativeScroll() * (72f / mGameItemsHolder.getCreativeScrollAmount())));
-        final Collection<Item> items = mGameItemsHolder.getAllItems();
-        for (int i = mGameInput.getCreativeScroll() * 8; i < mGameInput.getCreativeScroll() * 8 + 40; i++) {
-            if (i > 0 && i < items.size()) {
-                Item item = CollectionsKt.elementAt(items, i);
-                if (item != mGameItemsHolder.getFallbackItem()) {
-                    spriter.draw(CollectionsKt.elementAt(items, i).getSprite(),
-                            x + 8 + ((i - mGameInput.getCreativeScroll() * 8) % 8) * 18,
-                            y + 18 + ((i - mGameInput.getCreativeScroll() * 8) / 8) * 18);
-                }
-            }
-        }
-        for (int i = 0; i < 9; i++) {
-            if (mMobsController.getPlayer().inventory[i] != null && mMobsController.getPlayer().inventory[i] != mGameItemsHolder.getFallbackItem()) {
-                spriter.draw(mMobsController.getPlayer().inventory[i].getSprite(),
-                        x + 8 + i * 18, y + creative.getRegionHeight() - 24);
+        if (mMainConfig.isTouch()) {
+            @CheckForNull TouchButton touchedKey = getTouchedKey(touchX, touchY);
+            if (touchedKey != null && touchedKey.isMouse()) {
+                return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), true);
+            } else if (touchedKey != null) {
+                return keyUp(touchedKey.getCode());
             }
         }
 
+        return onMouseActionEvent(screenX, screenY, button, true);
     }
 
-    private void drawHealth(float x, float y) {
-        Player player = mMobsController.getPlayer();
-
-        if (player.gameMode == 1) {
-            return;
-        }
-
-        TextureRegion wholeHeart = textureRegions.get("heart_whole");
-        TextureRegion halfHeart = textureRegions.get("heart_half");
-
-        int wholeHearts = player.getHealth() / 2;
-
-        for (int i = 0; i < wholeHearts; i++) {
-            spriter.draw(wholeHeart, x + i * wholeHeart.getRegionWidth(), y);
-        }
-
-        if (player.getHealth() % 2 == 1) {
-            spriter.draw(halfHeart, x + wholeHearts * wholeHeart.getRegionWidth(), y);
+    @CheckForNull
+    private TouchButton getTouchedKey(float touchX, float touchY) {
+        for (ObjectMap.Entry<String, TouchButton> entry : Assets.guiMap) {
+            TouchButton button = entry.value;
+            if (button.getRect().contains(touchX, touchY)) {
+                return button;
+            }
         }
+        return null;
     }
 
-    private void drawGUI() {
-        TextureRegion cursor = textureRegions.get("cursor");
-        TextureRegion hotbar = textureRegions.get("hotbar");
-        TextureRegion hotbarSelector = textureRegions.get("hotbar_selector");
-
-        if (mGameWorld.hasForeAt(mGameInput.getCurX(), mGameInput.getCurY()) ||
-                mGameWorld.hasBackAt(mGameInput.getCurX(), mGameInput.getCurY()) ||
-                mGameInput.getControlMode() == ControlMode.CURSOR || mMainConfig.isTouch()) {
-            spriter.draw(cursor, mGameInput.getCurX() * 16 - getCamX(), mGameInput.getCurY() * 16 - getCamY());
-        }
-
-        float hotbarX = getWidth() / 2 - (float) hotbar.getRegionWidth() / 2;
-        spriter.draw(hotbar, hotbarX, 0);
-        drawHealth(hotbarX, hotbar.getRegionHeight());
+    @Override
+    public boolean touchDown(int screenX, int screenY, int pointer, int button) {
+        float touchX = transformScreenX(screenX);
+        float touchY = transformScreenY(screenY);
 
-        for (int i = 0; i < 9; i++) {
-            if (mMobsController.getPlayer().inventory[i] != null && mMobsController.getPlayer().inventory[i] != mGameItemsHolder.getFallbackItem()) {
-                spriter.draw(mMobsController.getPlayer().inventory[i].getSprite(),
-                        getWidth() / 2 - (float) hotbar.getRegionWidth() / 2 + 3 + i * 20,
-                        3);
+        if (mMainConfig.isTouch()) {
+            @CheckForNull TouchButton touchedKey = getTouchedKey(touchX, touchY);
+            if (touchedKey != null && touchedKey.isMouse()) {
+                return onMouseActionEvent(screenX, screenY, touchedKey.getCode(), false);
+            } else if (touchedKey != null) {
+                return keyDown(touchedKey.getCode());
             }
         }
-        spriter.draw(hotbarSelector,
-                getWidth() / 2 - (float) hotbar.getRegionWidth() / 2 - 1 + 20 * mMobsController.getPlayer().slot,
-                -1);
-    }
 
-    private void drawTouchGui() {
-        for (int i = 0; i < guiMap.size; i++) {
-            Rectangle touchKey = guiMap.getValueAt(i).getRect();
-            spriter.draw(textureRegions.get(guiMap.getKeyAt(i)),
-                    touchKey.x, touchKey.y, touchKey.width, touchKey.height);
-        }
-        if (mGameInput.getControlMode() == ControlMode.CURSOR) {
-            spriter.draw(textureRegions.get("shade"), 83, getHeight() - 21);
-        }
+        return onMouseActionEvent(screenX, screenY, button, false);
     }
 
-    private void drawGamePlay(float delta) {
-        Player player = mMobsController.getPlayer();
-
-        drawWorld(true);
-        player.draw(spriter, player.getX() - getCamX() - player.getWidth() / 2, player.getY() - getCamY(), delta);
-        mMobsController.getMobs().forEach((mob) -> {
-            drawMob(mob, delta);
-        });
-        mDropController.forEach(this::drawDrop);
-        drawWorld(false);
-        drawGUI();
+    @Override
+    public boolean touchDragged(int screenX, int screenY, int pointer) {
+        @CheckForNull MouseInputAction action =
+                mMouseInputActionMapper.mapDragged(screenX, screenY, getCameraViewport());
+        return handleMouseAction(action);
     }
 
-    private void updateCameraPosition() {
-        Player player = mMobsController.getPlayer();
-        setCamPos(player.getX() + player.getWidth() / 2 - getWidth() / 2,
-                player.getY() + player.getHeight() / 2 - getHeight() / 2);
+    @Override
+    public boolean scrolled(float amountX, float amountY) {
+        @CheckForNull MouseInputAction action = mMouseInputActionMapper
+                .mapScrolled(Gdx.input.getX(), Gdx.input.getY(), amountX, amountY, getCameraViewport());
+        return handleMouseAction(action);
     }
 
-    @Nullable
-    private Color getMinimapColor(int x, int y) {
-        @Nullable Color result = null;
+    private boolean handleKeyboardAction(int keycode, boolean isKeyDown) {
+        @CheckForNull final KeyboardInputAction action = mKeyboardInputActionMapper
+                .map(keycode, isKeyDown);
 
-        final boolean hasForeMap = mGameWorld.hasForeAt(x, y);
-        final boolean hasBackMap = mGameWorld.hasBackAt(x, y);
+        if (action == null) {
+            return false;
+        }
 
-        if (hasForeMap) {
-            final Block block = mGameWorld.getForeMap(x, y);
+        boolean anyProcessed = false;
 
-            if (block.isWater()) {
-                result = Color.BLUE;
-            } else if (block.isLava()) {
-                result = Color.RED;
-            } else {
-                result = Color.BLACK;
+        for (IGameInputHandler<KeyboardInputAction> handler : mKeyboardInputHandlers) {
+            final boolean conditions = handler.checkConditions(action);
+            if (conditions) {
+                anyProcessed = true;
+                handler.handle(action);
+                break;
             }
-        } else if (hasBackMap) {
-            result = Color.DARK_GRAY;
         }
 
-        return result;
+        return anyProcessed;
     }
 
-    private void drawMiniMap(float miniMapX, float miniMapY, float size) {
-        shaper.begin(ShapeRenderer.ShapeType.Filled);
-
-        shaper.setColor(Color.LIGHT_GRAY);
-        shaper.rect(miniMapX, miniMapY, size, size);
-
-        for (int x = 0; x < size; x++) {
-            for (int y = 0; y < size; y++) {
-
-                final int worldX = (int) (mMobsController.getPlayer().getMapX() - size / 2 + x);
-                final int worldY = (int) (mMobsController.getPlayer().getUpperMapY() - size / 2 + y);
-
-                @Nullable final Color color = getMinimapColor(worldX, worldY);
-
-                if (color != null) {
-                    shaper.setColor(color);
-                    shaper.rect(miniMapX + x, miniMapY + y, 1, 1);
-                }
-            }
-        }
+    @Override
+    public boolean keyDown(int keycode) {
+        return handleKeyboardAction(keycode, true);
+    }
 
-        shaper.setColor(Color.OLIVE);
-        shaper.rect(miniMapX + size / 2, miniMapY + size / 2, 1, 2);
-        shaper.end();
+    @Override
+    public boolean keyUp(int keycode) {
+        return handleKeyboardAction(keycode, false);
     }
 
     @Override
     public void render(float delta) {
-        int fps = MathUtils.ceil(1 / delta);
         updateCameraPosition();
-        mGameInput.moveCursor(this);
+        handleMousePosition();
+//        mGameInput.moveCursor(this);
 
         Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
 
         spriter.begin();
-
-        drawGamePlay(delta);
-
-        switch (mMainConfig.getGameUiWindow()) {
-            case CREATIVE_INVENTORY:
-                drawCreative();
-                break;
-            //TODO draw other ui windows
-        }
-
-
-        if (mMainConfig.isTouch()) {
-            drawTouchGui();
-        }
-
+        mRenderers.forEach(iGameRenderer -> iGameRenderer.draw(spriter, shaper, getCameraViewport(), delta));
         spriter.end();
-
-        if (mMainConfig.isShowMap()) {
-            drawMiniMap(getWidth() - 64f - 24f, 24f, 64f);
-        }
-
-        if (mMainConfig.isShowInfo()) {
-            spriter.begin();
-            Player player = mMobsController.getPlayer();
-            drawString("FPS: " + fps, 0, 0);
-            drawString("X: " + player.getMapX(), 0, 10);
-            drawString("Y: " + player.getUpperMapY(), 0, 20);
-            drawString("CurX: " + mGameInput.getCurX(), 0, 30);
-            drawString("CurY: " + mGameInput.getCurY(), 0, 40);
-            drawString("Velocity: " + player.getVelocity(), 0, 50);
-            drawString("Swim: " + player.swim, 0, 60);
-            drawString("Mobs: " + mMobsController.getMobs().size(), 0, 70);
-            drawString("Drops: " + mDropController.getSize(), 0, 80);
-            drawString("Block: " + mGameWorld.getForeMap(mGameInput.getCurX(), mGameInput.getCurY()).getParams().getKey(), 0, 90);
-            drawString("Hand: " + mMobsController.getPlayer().inventory[mMobsController.getPlayer().slot].getParams().getKey(), 0, 100);
-            drawString("Game mode: " + player.gameMode, 0, 110);
-            spriter.end();
-        }
-
     }
 
 }