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