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