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