core/src/ru/deadsoftware/cavedroid/game/mobs/player/Player.java

   1 package ru.deadsoftware.cavedroid.game.mobs.player;
   2
   3 import com.badlogic.gdx.graphics.g2d.Sprite;
   4 import com.badlogic.gdx.graphics.g2d.SpriteBatch;
   5 import com.badlogic.gdx.math.MathUtils;
   6 import com.badlogic.gdx.math.Vector2;
   7 import ru.deadsoftware.cavedroid.game.GameItemsHolder;
   8 import ru.deadsoftware.cavedroid.game.mobs.Mob;
   9 import ru.deadsoftware.cavedroid.game.mobs.MobsController;
  10 import ru.deadsoftware.cavedroid.game.model.block.Block;
  11 import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
  12 import ru.deadsoftware.cavedroid.game.model.item.Item;
  13 import ru.deadsoftware.cavedroid.game.objects.drop.Drop;
  14 import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
  15 import ru.deadsoftware.cavedroid.game.ui.TooltipManager;
  16 import ru.deadsoftware.cavedroid.game.world.GameWorld;
  17 import ru.deadsoftware.cavedroid.misc.Assets;
  18 import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin;
  19 import ru.deadsoftware.cavedroid.misc.utils.SpriteUtilsKt;
  20
  21 import javax.annotation.CheckForNull;
  22
  23 public class Player extends Mob {
  24
  25     private static final float SPEED = 69.072f;
  26     private static final float JUMP_VELOCITY = -133.332f;
  27     private static final int SURVIVAL_CURSOR_RANGE = 4;
  28
  29     public static final int MAX_HEALTH = 20;
  30     public static final int INVENTORY_SIZE = 36;
  31     public static final int HOTBAR_SIZE = 9;
  32
  33     private boolean hitting = false, hittingWithDamage = false;
  34     private float hitAnim = 0f;
  35     private float hitAnimDelta = ANIMATION_SPEED;
  36
  37     public final Inventory inventory;
  38
  39     public int gameMode;
  40     public boolean swim;
  41     public float headRotation = 0f;
  42
  43     public float blockDamage = 0f;
  44     public int cursorX = 0;
  45     public int cursorY = 0;
  46
  47     @CheckForNull
  48     private Vector2 spawnPoint = null;
  49
  50     public ControlMode controlMode = ControlMode.WALK;
  51
  52     public enum ControlMode {
  53         WALK,
  54         CURSOR
  55     }
  56
  57     public Player(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
  58         super(0, 0, 4, 30, randomDir(), Type.MOB, MAX_HEALTH);
  59         inventory = new Inventory(INVENTORY_SIZE, HOTBAR_SIZE, gameItemsHolder, tooltipManager);
  60         swim = false;
  61     }
  62
  63     public void initInventory(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
  64         inventory.initItems(gameItemsHolder, tooltipManager);
  65     }
  66
  67     public void respawn(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  68         Vector2 pos = getSpawnPoint(gameWorld, itemsHolder);
  69         this.x = pos.x;
  70         this.y = pos.y;
  71         mVelocity.setZero();
  72         mDead = false;
  73         heal(MAX_HEALTH);
  74     }
  75
  76     public void decreaseCurrentItemCount(GameItemsHolder gameItemsHolder) {
  77         if (gameMode == 1) {
  78             return;
  79         }
  80
  81         final InventoryItem item = inventory.getActiveItem();
  82         item.subtract();
  83         if (item.getAmount() <= 0) {
  84             setCurrentInventorySlotItem(gameItemsHolder.getFallbackItem());
  85         }
  86     }
  87
  88     public void dropCurrentItem(DropController dropController) {
  89         final InventoryItem activeItem = inventory.getActiveItem();
  90
  91     }
  92
  93     private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  94         if (spawnPoint != null) {
  95             return spawnPoint;
  96         }
  97
  98         int y, x = gameWorld.getWidth() / 2;
  99         for (y = 0; y <= gameWorld.getWorldConfig().getSeaLevel(); y++) {
 100             if (y == gameWorld.getWorldConfig().getSeaLevel()) {
 101                 for (x = 0; x < gameWorld.getWidth(); x++) {
 102                     if (gameWorld.getForeMap(x, y).getParams().getHasCollision()) {
 103                         break;
 104                     }
 105                     if (x == gameWorld.getWidth() - 1) {
 106                         gameWorld.setForeMap(x, y, itemsHolder.getBlock("grass"));
 107                         break;
 108                     }
 109                 }
 110                 break;
 111             }
 112             if (gameWorld.hasForeAt(x, y) && gameWorld.getForeMap(x, y).hasCollision()) {
 113                 break;
 114             }
 115         }
 116         spawnPoint = new Vector2(x * 16 + 8 - getWidth() / 2, (float) y * 16 - getHeight());
 117         return spawnPoint;
 118     }
 119
 120     public void setDir(Direction dir) {
 121         if (dir != getDirection()) {
 122             switchDir();
 123         }
 124     }
 125
 126     public void setCurrentInventorySlotItem(Item item) {
 127         inventory.getItems().set(inventory.getActiveSlot(), item.toInventoryItem());
 128     }
 129
 130     @Override
 131     public float getSpeed() {
 132         return SPEED;
 133     }
 134
 135     @Override
 136     public void jump() {
 137         if (!canJump()) {
 138             if (gameMode == 1) {
 139                 if (isFlyMode()) {
 140                     setFlyMode(false);
 141                 } else {
 142                     getVelocity().y = 0f;
 143                     setFlyMode(true);
 144                 }
 145             }
 146             return;
 147         }
 148         mVelocity.y = JUMP_VELOCITY;
 149     }
 150
 151     private boolean checkBlockCanBeHit(Block block) {
 152         return !block.isNone() && block.getParams().getHitPoints() >= 0;
 153     }
 154
 155     /**
 156      * @return true if any mob fas hit
 157      */
 158     private boolean hitMobs(GameItemsHolder gameItemsHolder, MobsController mobsController) {
 159         if (!hitting || !hittingWithDamage) {
 160             return false;
 161         }
 162
 163         boolean result = false;
 164         for (Mob mob : mobsController.getMobs()) {
 165             if (overlaps(mob.getHitBox())) {
 166                 final Item activeItem = inventory.getActiveItem().getItem();
 167                 final Item.Tool tool = activeItem.isTool() ? (Item.Tool) activeItem : null;
 168                 if (tool != null) {
 169                     decreaseCurrentItemCount(gameItemsHolder);
 170                 }
 171                 result = true;
 172                 mob.damage(MathUtils.floor(tool != null ? tool.getMobDamageMultiplier() : 1));
 173             }
 174         }
 175         return result;
 176     }
 177
 178     private void hitBlock(GameWorld gameWorld, GameItemsHolder gameItemsHolder) {
 179         if (!hitting || !hittingWithDamage) {
 180             return;
 181         }
 182
 183         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 184         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 185
 186
 187         if ((checkBlockCanBeHit(foregroundBlock)) ||
 188                 (foregroundBlock.isNone() && checkBlockCanBeHit(backgroundBlock))) {
 189             if (gameMode == 0) {
 190                 if (!foregroundBlock.isNone()) {
 191                     if (blockDamage >= foregroundBlock.getParams().getHitPoints()) {
 192                         gameWorld.destroyForeMap(cursorX, cursorY);
 193                         blockDamage = 0;
 194                     }
 195                 } else if (!backgroundBlock.isNone()) {
 196                     if (blockDamage >= backgroundBlock.getParams().getHitPoints()) {
 197                         gameWorld.destroyBackMap(cursorX, cursorY);
 198                         blockDamage = 0;
 199                     }
 200                 }
 201             } else {
 202                 if (!foregroundBlock.isNone()) {
 203                     gameWorld.placeToForeground(cursorX, cursorY, gameItemsHolder.getFallbackBlock());
 204                 } else if (!backgroundBlock.isNone()) {
 205                     gameWorld.placeToBackground(cursorX, cursorY, gameItemsHolder.getFallbackBlock());
 206                 }
 207                 stopHitting();
 208             }
 209         } else {
 210             stopHitting();
 211         }
 212     }
 213
 214     @Override
 215     public void ai(GameWorld gameWorld, GameItemsHolder gameItemsHolder, MobsController mobsController, float delta) {
 216         updateAnimation(delta);
 217
 218         if (!hitMobs(gameItemsHolder, mobsController)) {
 219             hitBlock(gameWorld, gameItemsHolder);
 220         } else {
 221             stopHitting();
 222         }
 223
 224         if (gameMode == 1) {
 225             return;
 226         }
 227
 228         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 229         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 230         @CheckForNull final Block target;
 231
 232         if (checkBlockCanBeHit(foregroundBlock)) {
 233             target = foregroundBlock;
 234         } else if (checkBlockCanBeHit(backgroundBlock)) {
 235             target = backgroundBlock;
 236         } else {
 237             target = null;
 238         }
 239
 240         final boolean canHitBlock = target != null;
 241
 242         float multiplier = 1f;
 243         final Item currentItem = inventory.getActiveItem().getItem();
 244         if (currentItem instanceof Item.Tool && canHitBlock) {
 245             if (target.getParams().getToolType() == currentItem.getClass()
 246                     && ((Item.Tool)currentItem).getLevel() >= target.getParams().getToolLevel()) {
 247                 multiplier = 2f * ((Item.Tool)currentItem).getLevel();
 248             }
 249             multiplier *= ((Item.Tool)currentItem).getBlockDamageMultiplier();
 250         }
 251
 252         if (hitting && hittingWithDamage && canHitBlock) {
 253             blockDamage += 60f * delta * multiplier;
 254         } else {
 255             blockDamage = 0f;
 256         }
 257     }
 258
 259     @Override
 260     public void changeDir() {
 261     }
 262
 263     @Override
 264     public void damage(int damage) {
 265         if (gameMode == 1) {
 266             return;
 267         }
 268
 269         if (damage > 0) {
 270             getVelocity().y += JUMP_VELOCITY / 3f;
 271         }
 272
 273         super.damage(damage);
 274     }
 275
 276     @Override
 277     public void heal(int heal) {
 278         if (gameMode == 1) {
 279             return;
 280         }
 281         super.heal(heal);
 282     }
 283
 284     public void checkCursorBounds(GameWorld gameWorld) {
 285         if (gameMode == 0) {
 286             int minCursorX = getMapX() - SURVIVAL_CURSOR_RANGE;
 287             int maxCursorX = getMapX() + SURVIVAL_CURSOR_RANGE;
 288             int minCursorY = getMiddleMapY() - SURVIVAL_CURSOR_RANGE;
 289             int maxCursorY = getMiddleMapY() + SURVIVAL_CURSOR_RANGE;
 290
 291             cursorX = MathUtils.clamp(cursorX, minCursorX, maxCursorX);
 292             cursorY = MathUtils.clamp(cursorY, minCursorY, maxCursorY);
 293         }
 294
 295         cursorY = MathUtils.clamp(cursorY, 0, gameWorld.getHeight() - 1);
 296     }
 297
 298     private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
 299         final Item item = inventory.getActiveItem().getItem();
 300
 301         if (item == null || item.isNone()) {
 302             return;
 303         }
 304
 305         final Sprite sprite = item.getSprite();
 306         final boolean smallSprite = !item.isTool() || item.isShears();
 307
 308         final float originalWidth = sprite.getWidth();
 309         final float originalHeight = sprite.getHeight();
 310
 311         if (smallSprite) {
 312             sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
 313         }
 314
 315         final float handLength = Assets.playerSprite[0][2].getHeight();
 316
 317         final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
 318         final int handMultiplier = -getDirection().getBasis();
 319         final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
 320         final float yOffset = !smallSprite ? -sprite.getHeight() / 2 : 0;
 321
 322         float rotate = anim + 30;
 323
 324         if (item.isTool()) {
 325             sprite.rotate90(looksLeft());
 326         }
 327
 328         final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
 329         final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
 330
 331         if (looksLeft()) {
 332             sprite.setFlip(!item.isTool(), sprite.isFlipY());
 333             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
 334         } else {
 335             sprite.setFlip(item.isTool(), sprite.isFlipY());
 336             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
 337         }
 338
 339         sprite.setRotation(-handMultiplier * rotate);
 340         sprite.setPosition(itemX, itemY);
 341         sprite.draw(spriteBatch);
 342
 343         // dont forget to reset
 344         sprite.setFlip(false, sprite.isFlipY());
 345         sprite.setRotation(0);
 346         sprite.setOriginCenter();
 347         sprite.setSize(originalWidth, originalHeight);
 348         if (item.isTool()) {
 349             sprite.rotate90(looksRight());
 350         }
 351     }
 352
 353     public void startHitting(boolean withDamage) {
 354         if (hitting) {
 355             return;
 356         }
 357
 358         hitting = true;
 359         hittingWithDamage = withDamage;
 360         hitAnim = 90f;
 361         hitAnimDelta = ANIMATION_SPEED;
 362     }
 363
 364     public void startHitting() {
 365         startHitting(true);
 366     }
 367
 368     public void stopHitting() {
 369         blockDamage = 0f;
 370         hitting = false;
 371     }
 372
 373     private float getRightHandAnim(float delta) {
 374         hitAnim -= hitAnimDelta * delta;
 375
 376         if (hitAnim < 30f || hitAnim > 90f) {
 377             if (hitting) {
 378                 hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
 379                 hitAnimDelta = -hitAnimDelta;
 380             } else  {
 381                 hitAnimDelta = ANIMATION_SPEED;
 382             }
 383         }
 384
 385         if (!hitting) {
 386             if (hitAnim < hitAnimDelta * delta) {
 387                 hitAnim = 0;
 388                 hitAnimDelta = 0;
 389                 return -mAnim;
 390             }
 391         }
 392
 393         return hitAnim;
 394     }
 395
 396     @Override
 397     public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
 398         final Sprite backHand = Assets.playerSprite[1][2];
 399         final Sprite backLeg = Assets.playerSprite[1][3];
 400         final Sprite frontLeg = Assets.playerSprite[0][3];
 401         final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
 402         final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
 403         final Sprite frontHand = Assets.playerSprite[0][2];
 404
 405         float backHandAnim, frontHandAnim;
 406
 407         final float rightHandAnim = getRightHandAnim(delta);
 408
 409         if (looksLeft()) {
 410             backHandAnim = rightHandAnim;
 411             frontHandAnim = mAnim;
 412         } else {
 413             backHandAnim = -mAnim;
 414             frontHandAnim = -rightHandAnim;
 415         }
 416
 417         backHand.setColor(getTintColor());
 418         backLeg.setColor(getTintColor());
 419         frontLeg.setColor(getTintColor());
 420         head.setColor(getTintColor());
 421         body.setColor(getTintColor());
 422         frontHand.setColor(getTintColor());
 423
 424         SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
 425
 426         if (looksLeft()) {
 427             drawItem(spriteBatch, x, y, -backHandAnim);
 428         }
 429
 430         SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
 431         SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
 432         SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
 433         SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
 434
 435         if (looksRight()) {
 436             drawItem(spriteBatch, x, y, frontHandAnim);
 437         }
 438
 439         SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
 440     }
 441
 442 }