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

   1 package ru.deadsoftware.cavedroid.game;
   2
   3 import com.badlogic.gdx.math.Intersector;
   4 import com.badlogic.gdx.math.MathUtils;
   5 import com.badlogic.gdx.math.Rectangle;
   6 import com.badlogic.gdx.math.Vector2;
   7 import org.jetbrains.annotations.NotNull;
   8 import ru.deadsoftware.cavedroid.CaveGame;
   9 import ru.deadsoftware.cavedroid.game.mobs.Mob;
  10 import ru.deadsoftware.cavedroid.game.mobs.Player;
  11 import ru.deadsoftware.cavedroid.game.objects.Drop;
  12
  13 import java.util.Iterator;
  14
  15 import static ru.deadsoftware.cavedroid.GameScreen.GP;
  16
  17 class GamePhysics {
  18
  19     static final int PL_SPEED = 2;
  20
  21     private final Vector2 gravity = new Vector2(0, .9f);
  22
  23     /**
  24      * Checks if mob should jump
  25      *
  26      * @return true if mob should jump
  27      */
  28     private boolean checkJump(@NotNull Mob mob) {
  29         int dir = mob.looksLeft() ? 0 : 1;
  30         int blX = (int) (mob.getX() + mob.getWidth() * dir - 8 + 16 * dir);
  31         int blY = (int) (mob.getY() + mob.getHeight() - 8);
  32         int block = GP.world.getForeMap(blX / 16, blY / 16);
  33
  34         if (checkColl(new Rectangle(blX, mob.getY() - 18, mob.getWidth(), mob.getHeight()))) {
  35             block = 0;
  36         }
  37
  38         return (block > 0 && GameItems.getBlock(block).toJump() &&
  39                 (mob.getY() + mob.getHeight()) - GameItems.getBlock(block).getRect(blX / 16, blY / 16).y > 8);
  40     }
  41
  42     private boolean checkColl(@NotNull Rectangle rect) {
  43         int minX = (int) ((rect.x + rect.width / 2) / 16) - 4;
  44         int minY = (int) ((rect.y + rect.height / 2) / 16) - 4;
  45         int maxX = (int) ((rect.x + rect.width / 2) / 16) + 4;
  46         int maxY = (int) ((rect.y + rect.height / 2) / 16) + 4;
  47
  48         if (minY < 0) {
  49             minY = 0;
  50         }
  51
  52         if (maxY > GP.world.getHeight()) {
  53             maxY = GP.world.getHeight();
  54         }
  55
  56         int block;
  57         for (int y = minY; y < maxY; y++) {
  58             for (int x = minX; x < maxX; x++) {
  59                 block = GP.world.getForeMap(x, y);
  60                 if (block > 0 && GameItems.getBlock(block).hasCollision()) {
  61                     if (Intersector.overlaps(rect, GameItems.getBlock(block).getRect(x, y))) {
  62                         return true;
  63                     }
  64                 }
  65             }
  66         }
  67
  68         return false;
  69     }
  70
  71     private int getBlock(@NotNull Rectangle rect) {
  72         return GP.world.getForeMap((int) (rect.x + rect.width / 2) / 16,
  73                 (int) (rect.y + rect.height / 8 * 7) / 16);
  74     }
  75
  76     private void dropPhy(Drop drop) {
  77         if (drop.closeToPlayer() > 0) {
  78             drop.moveToPlayer();
  79         } else {
  80             if (drop.getMove().x >= .5f) {
  81                 drop.getMove().x -= .5f;
  82             } else if (drop.getMove().x <= -.5f) {
  83                 drop.getMove().x += .5f;
  84             } else {
  85                 drop.getMove().x = 0;
  86             }
  87             if (drop.getMove().y < 9) {
  88                 drop.getMove().y += gravity.y / 4;
  89             }
  90         }
  91         drop.move();
  92
  93
  94         if (checkColl(drop)) {
  95             drop.getMove().set(0, -1);
  96             do {
  97                 drop.move();
  98             } while (checkColl(drop));
  99             drop.getMove().setZero();
 100         }
 101     }
 102
 103     private void mobXColl(Mob mob) {
 104         if (checkColl(mob)) {
 105             if (mob.canJump() && !mob.isFlyMode()) {
 106                 mob.y -= 8;
 107             }
 108
 109             if (checkColl(mob)) {
 110                 if (mob.canJump() && !mob.isFlyMode()) {
 111                     mob.y += 8;
 112                 }
 113
 114                 int d = 0;
 115
 116                 if (mob.getMove().x < 0) {
 117                     d = 1;
 118                 } else if (mob.getMove().x > 0) {
 119                     d = -1;
 120                 }
 121
 122                 mob.x = MathUtils.round(mob.getX());
 123
 124                 while (checkColl(mob)) {
 125                     mob.x += d;
 126                 }
 127
 128                 if (mob.canJump()) {
 129                     mob.changeDir();
 130                 }
 131             }
 132         }
 133
 134         mob.checkWorldBounds();
 135     }
 136
 137     private void mobYColl(Mob mob) {
 138         if (checkColl(mob)) {
 139             int d = -1;
 140
 141             if (mob.getMove().y < 0) {
 142                 d = 1;
 143             }
 144
 145             if (d == -1) {
 146                 mob.setCanJump(true);
 147                 mob.setFlyMode(false);
 148             }
 149
 150             mob.y = MathUtils.round(mob.getY());
 151
 152             while (checkColl(mob)) {
 153                 mob.y += d;
 154             }
 155
 156             mob.getMove().y = 0;
 157
 158         } else {
 159             mob.setCanJump(false);
 160         }
 161
 162         if (mob.getY() > GP.world.getHeightPx()) {
 163             mob.kill();
 164         }
 165     }
 166
 167     private void playerPhy(Player player) {
 168         player.y += player.getMove().y;
 169         mobYColl(player);
 170
 171         if (player.isDead()) {
 172             return;
 173         }
 174
 175         if (GameItems.isFluid(getBlock(player))) {
 176             if (CaveGame.TOUCH && player.getMove().x != 0 && !player.swim && !player.isFlyMode()) {
 177                 player.swim = true;
 178             }
 179             if (!player.swim) {
 180                 if (!player.isFlyMode() && player.getMove().y < 4.5f) {
 181                     player.getMove().add(gravity.x / 4, gravity.y / 4);
 182                 }
 183                 if (!player.isFlyMode() && player.getMove().y > 4.5f) {
 184                     player.getMove().add(0, -1f);
 185                 }
 186             } else {
 187                 player.getMove().add(0, -.5f);
 188                 if (player.getMove().y < -3) {
 189                     player.getMove().y = -3;
 190                 }
 191             }
 192         } else {
 193             if (!player.isFlyMode() && player.getMove().y < 18) {
 194                 player.getMove().add(gravity);
 195             }
 196         }
 197
 198         player.x += player.getMove().x * (player.isFlyMode() ? 1.5f : 1) * (GameItems.isFluid(getBlock(player)) && !player.isFlyMode() ? .8f : 1);
 199         mobXColl(player);
 200
 201         if (CaveGame.TOUCH && !player.isFlyMode() && player.canJump() && player.getMove().x != 0 && checkJump(player)) {
 202             player.getMove().add(0, -8);
 203             player.setCanJump(false);
 204         }
 205     }
 206
 207     private void mobPhy(Mob mob) {
 208         if (mob.getType() == Mob.Type.MOB && GameItems.isFluid(getBlock(mob))) {
 209             if (mob.getMove().y > 9) {
 210                 mob.getMove().add(0, -.9f);
 211             }
 212
 213             mob.getMove().add(0, -.5f);
 214
 215             if (mob.getMove().y < -3) {
 216                 mob.getMove().y = -3;
 217             }
 218         } else if (!mob.isFlyMode() && mob.getMove().y < 18) {
 219             mob.getMove().add(gravity);
 220         }
 221
 222         mob.y += mob.getMove().y;
 223         mobYColl(mob);
 224
 225         if (mob.isDead()) {
 226             return;
 227         }
 228
 229         mob.x += mob.getMove().x;
 230         mobXColl(mob);
 231
 232         if (mob.canJump() && mob.getMove().x != 0 && checkJump(mob)) {
 233             mob.getMove().add(0, -8);
 234             mob.setCanJump(false);
 235         }
 236     }
 237
 238     void update() {
 239         for (Iterator<Drop> it = GP.drops.iterator(); it.hasNext(); ) {
 240             Drop drop = it.next();
 241             dropPhy(drop);
 242             if (Intersector.overlaps(drop, GP.player)) {
 243                 drop.pickUpDrop(GP.player);
 244             }
 245             if (drop.isPickedUp()) {
 246                 it.remove();
 247             }
 248         }
 249
 250         for (Iterator<Mob> it = GP.mobs.iterator(); it.hasNext(); ) {
 251             Mob mob = it.next();
 252             mob.ai();
 253             mobPhy(mob);
 254             if (mob.isDead()) {
 255                 it.remove();
 256             }
 257         }
 258
 259         playerPhy(GP.player);
 260         if (GP.player.isDead()) {
 261             GP.player.respawn();
 262         }
 263
 264         GP.renderer.setCamPos(GP.player.getX() + GP.player.getWidth() / 2 - GP.renderer.getWidth() / 2,
 265                 GP.player.getY() + GP.player.getHeight() / 2 - GP.renderer.getHeight() / 2);
 266     }
 267
 268 }