core/src/ru/deadsoftware/cavedroid/game/GameProc.java

   1 package ru.deadsoftware.cavedroid.game;
   2
   3 import com.badlogic.gdx.Gdx;
   4 import com.badlogic.gdx.Input;
   5 import com.badlogic.gdx.utils.Disposable;
   6 import com.badlogic.gdx.utils.TimeUtils;
   7 import ru.deadsoftware.cavedroid.CaveGame;
   8 import ru.deadsoftware.cavedroid.GameScreen;
   9 import ru.deadsoftware.cavedroid.game.mobs.FallingGravel;
  10 import ru.deadsoftware.cavedroid.game.mobs.FallingSand;
  11 import ru.deadsoftware.cavedroid.game.mobs.Mob;
  12 import ru.deadsoftware.cavedroid.game.objects.Drop;
  13 import ru.deadsoftware.cavedroid.game.objects.Player;
  14 import ru.deadsoftware.cavedroid.misc.ControlMode;
  15 import ru.deadsoftware.cavedroid.misc.Assets;
  16 import ru.deadsoftware.cavedroid.misc.states.GameState;
  17
  18 import java.io.Serializable;
  19 import java.util.ArrayList;
  20
  21 import static ru.deadsoftware.cavedroid.game.GameItems.*;
  22
  23 public class GameProc implements Serializable, Disposable {
  24
  25     static final int MAX_CREATIVE_SCROLL = getItemsSize() / 8;
  26
  27     private static final int WORLD_WIDTH = 1024;
  28     private static final int WORLD_HEIGHT = 256;
  29     private static final int UPD_RANGE = 16;
  30
  31     static boolean DO_UPD = false;
  32     static int UPD_X = -1, UPD_Y = -1;
  33
  34     private transient GameFluidsThread fluidThread;
  35     public transient GameWorld world;
  36     public transient GameRenderer renderer;
  37     transient GamePhysics physics;
  38
  39     public ControlMode controlMode;
  40     public Player player;
  41     public ArrayList<Mob> mobs;
  42     ArrayList<Drop> drops;
  43
  44     public boolean isTouchDown, isKeyDown;
  45     public int touchDownX, touchDownY, touchDownBtn, keyDownCode;
  46     long touchDownTime;
  47
  48     int curX, curY;
  49     int creativeScroll;
  50     int blockDmg = 0;
  51
  52     public GameProc(int gameMode) {
  53         world = new GameWorld(WORLD_WIDTH, WORLD_HEIGHT);
  54         player = new Player(gameMode);
  55         drops = new ArrayList<>();
  56         mobs = new ArrayList<>();
  57         physics = new GamePhysics();
  58         controlMode = CaveGame.TOUCH ? ControlMode.WALK : ControlMode.CURSOR;
  59         resetRenderer();
  60         startFluidThread();
  61     }
  62
  63     public void resetRenderer() {
  64         int scale = CaveGame.TOUCH ? 320 : 480;
  65         renderer = new GameRenderer(scale, scale * GameScreen.getHeight() / GameScreen.getWidth());
  66     }
  67
  68     private void startFluidThread() {
  69         fluidThread = new GameFluidsThread();
  70         fluidThread.start();
  71     }
  72
  73     private boolean isNotAutoselectable(int x, int y) {
  74         return (!world.hasForeAt(x, y) || !world.getForeMapBlock(x, y).hasCollision());
  75     }
  76
  77     private void checkCursorBounds() {
  78         if (curY < 0) {
  79             curY = 0;
  80         } else if (curY >= world.getHeight()) {
  81             curY = world.getHeight() - 1;
  82         }
  83
  84         if (controlMode == ControlMode.CURSOR) {
  85             if (curX * 16 + 8 < player.pos.x + player.getWidth() / 2) {
  86                 player.setDir(0);
  87             } else {
  88                 player.setDir(1);
  89             }
  90         }
  91     }
  92
  93     private void moveCursor() {
  94         int pastX = curX;
  95         int pastY = curY;
  96
  97         if (controlMode == ControlMode.WALK && CaveGame.TOUCH) {
  98             curX = player.getMapX() + (player.looksLeft() ? -1 : 1);
  99             curY = player.getUpperMapY();
 100             for (int i = 0; i < 2 && isNotAutoselectable(curX, curY); i++) {
 101                 curY++;
 102             }
 103             if (isNotAutoselectable(curX, curY)) {
 104                 curX += player.looksLeft() ? 1 : -1;
 105             }
 106         } else if (!CaveGame.TOUCH) {
 107             curX = (int) (Gdx.input.getX() * (renderer.getWidth() / GameScreen.getWidth()) + renderer.getCamX()) / 16;
 108             curY = (int) (Gdx.input.getY() * (renderer.getHeight() / GameScreen.getHeight()) + renderer.getCamY()) / 16;
 109             if (curX < 0) curX--;
 110         }
 111
 112         if (pastX != curX || pastY != curY) {
 113             blockDmg = 0;
 114         }
 115
 116         checkCursorBounds();
 117     }
 118
 119     private void updateBlock(int x, int y) {
 120         if (world.getForeMap(x, y) == 10) {
 121             if (!world.hasForeAt(x, y + 1) || !world.getForeMapBlock(x, y + 1).hasCollision()) {
 122                 world.setForeMap(x, y, 0);
 123                 mobs.add(new FallingSand(x * 16, y * 16));
 124                 updateBlock(x, y - 1);
 125             }
 126         }
 127
 128         if (world.getForeMap(x, y) == 11) {
 129             if (!world.hasForeAt(x, y + 1) || !world.getForeMapBlock(x, y + 1).hasCollision()) {
 130                 world.setForeMap(x, y, 0);
 131                 mobs.add(new FallingGravel(x * 16, y * 16));
 132                 updateBlock(x, y - 1);
 133             }
 134         }
 135
 136         if (world.hasForeAt(x, y) && world.getForeMapBlock(x, y).requiresBlock()) {
 137             if (!world.hasForeAt(x, y + 1) || !world.getForeMapBlock(x, y + 1).hasCollision()) {
 138                 world.destroyForeMap(x, y);
 139                 updateBlock(x, y - 1);
 140             }
 141         }
 142
 143         if (world.getForeMap(x, y) == 2) {
 144             if (world.hasForeAt(x, y - 1) && (world.getForeMapBlock(x, y - 1).hasCollision() ||
 145                     isFluid(world.getForeMap(x, y - 1)))) {
 146                 world.setForeMap(x, y, 3);
 147             }
 148         }
 149     }
 150
 151     private void blockUpdater() {
 152         if (DO_UPD) {
 153             for (int y = UPD_Y; y < UPD_Y + UPD_RANGE; y++) {
 154                 for (int x = UPD_X; x < UPD_X + UPD_RANGE; x++) {
 155                     updateBlock(x, y);
 156                 }
 157             }
 158             DO_UPD = false;
 159         }
 160     }
 161
 162     void useItem(int x, int y, int id, boolean bg) {
 163         String key = getItem(id).isBlock() ? getBlockKey(id) : getItemKey(id);
 164         if (id > 0) {
 165             if (getItem(id).isBlock()) {
 166                 if (!bg) {
 167                     world.placeToForeground(x, y, getBlockIdByItemId(id));
 168                 } else {
 169                     world.placeToBackground(x, y, getBlockIdByItemId(id));
 170                 }
 171             } else {
 172                 switch (key) {
 173                     case "bucket_water":
 174                         world.placeToForeground(x, y, getBlockId("water"));
 175                         player.inventory[player.slot] = getItemId("bucket_empty");
 176                         break;
 177                     case "bucket_lava":
 178                         world.placeToForeground(x, y, getBlockId("lava"));
 179                         player.inventory[player.slot] = getItemId("bucket_empty");
 180                         break;
 181                 }
 182             }
 183         }
 184     }
 185
 186     private void pressLMB() {
 187         if ((world.hasForeAt(curX, curY) && world.getForeMapBlock(curX, curY).getHp() >= 0) ||
 188                 (!world.hasForeAt(curX, curY) && world.hasBackAt(curX, curY) &&
 189                         world.getBackMapBlock(curX, curY).getHp() >= 0)) {
 190             if (player.gameMode == 0) {
 191                 blockDmg++;
 192                 if (world.hasForeAt(curX, curY)) {
 193                     if (blockDmg >= world.getForeMapBlock(curX, curY).getHp()) {
 194                         world.destroyForeMap(curX, curY);
 195                         blockDmg = 0;
 196                     }
 197                 } else if (world.hasBackAt(curX, curY)) {
 198                     if (blockDmg >= world.getBackMapBlock(curX, curY).getHp()) {
 199                         world.destroyBackMap(curX, curY);
 200                         blockDmg = 0;
 201                     }
 202                 }
 203             } else {
 204                 if (world.hasForeAt(curX, curY)) {
 205                     world.placeToForeground(curX, curY, 0);
 206                 } else if (world.hasBackAt(curX, curY)) {
 207                     world.placeToBackground(curX, curY, 0);
 208                 }
 209                 isTouchDown = false;
 210             }
 211         }
 212     }
 213
 214     private void holdMB() {
 215         switch (touchDownBtn) {
 216             case Input.Buttons.RIGHT:
 217                 useItem(curX, curY, player.inventory[player.slot], true);
 218                 isTouchDown = false;
 219                 break;
 220             case Input.Buttons.LEFT:
 221                 break;
 222             default:
 223                 if (touchDownY < Assets.invBar.getRegionHeight() &&
 224                         touchDownX > renderer.getWidth() / 2 - (float) Assets.invBar.getRegionWidth() / 2 &&
 225                         touchDownX < renderer.getWidth() / 2 + (float) Assets.invBar.getRegionWidth() / 2) {
 226                     CaveGame.GAME_STATE= GameState.CREATIVE_INV;
 227                     isTouchDown = false;
 228                 }
 229         }
 230     }
 231
 232     public void update() {
 233         physics.update();
 234         moveCursor();
 235
 236         if (isTouchDown && touchDownBtn == Input.Buttons.LEFT) pressLMB();
 237         if (isTouchDown && TimeUtils.timeSinceMillis(touchDownTime) > 500) holdMB();
 238         if (fluidThread == null || !fluidThread.isAlive()) startFluidThread();
 239     }
 240
 241     @Override
 242     public void dispose() {
 243         fluidThread.interrupt();
 244     }
 245 }