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