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

   1 package ru.deadsoftware.cavedroid.game.mobs;
   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.model.block.Block;
   9 import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
  10 import ru.deadsoftware.cavedroid.game.model.item.Item;
  11 import ru.deadsoftware.cavedroid.game.objects.Drop;
  12 import ru.deadsoftware.cavedroid.game.world.GameWorld;
  13 import ru.deadsoftware.cavedroid.misc.Assets;
  14 import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin;
  15 import ru.deadsoftware.cavedroid.misc.utils.SpriteUtilsKt;
  16
  17 import javax.annotation.CheckForNull;
  18 import java.util.ArrayList;
  19
  20 public class Player extends Mob {
  21
  22     private static final float SPEED = 69.072f;
  23     private static final float JUMP_VELOCITY = -133.332f;
  24     private static final int MAX_HEALTH = 20;
  25
  26     private boolean hitting = false, hittingWithDamage = false;
  27     private float hitAnim = 0f;
  28     private float hitAnimDelta = ANIMATION_SPEED;
  29
  30     public final ArrayList<InventoryItem> inventory;
  31     public int slot;
  32     public int gameMode;
  33     public boolean swim;
  34     public float headRotation = 0f;
  35
  36     public float blockDamage = 0f;
  37     public int cursorX = 0;
  38     public int cursorY = 0;
  39
  40     @CheckForNull
  41     private Vector2 spawnPoint = null;
  42
  43     public ControlMode controlMode = ControlMode.WALK;
  44
  45     public enum ControlMode {
  46         WALK,
  47         CURSOR
  48     }
  49
  50     public Player(GameItemsHolder gameItemsHolder) {
  51         super(0, 0, 4, 30, randomDir(), Type.MOB, MAX_HEALTH);
  52         inventory = new ArrayList<>(36);
  53         for (int i = 0; i < 36; i++) {
  54             inventory.add(gameItemsHolder.getFallbackItem().toInventoryItem());
  55         }
  56         swim = false;
  57     }
  58
  59     public void initInventory(GameItemsHolder gameItemsHolder) {
  60         for (InventoryItem invItem : inventory) {
  61             invItem.init(gameItemsHolder);
  62         }
  63     }
  64
  65     public void respawn(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  66         Vector2 pos = getSpawnPoint(gameWorld, itemsHolder);
  67         this.x = pos.x;
  68         this.y = pos.y;
  69         mVelocity.setZero();
  70         mDead = false;
  71         heal(MAX_HEALTH);
  72     }
  73
  74     public void decreaseCurrentItemCount(GameItemsHolder gameItemsHolder) {
  75         if (gameMode == 1) {
  76             return;
  77         }
  78         getCurrentItem().setAmount(getCurrentItem().getAmount() - 1);
  79         if (getCurrentItem().getAmount() <= 0) {
  80             setCurrentInventorySlotItem(gameItemsHolder.getFallbackItem());
  81         }
  82     }
  83
  84     public InventoryItem getCurrentItem() {
  85         return inventory.get(slot);
  86     }
  87
  88     /**
  89      * @return index of inventory where this drop could be placed or -1 if cant pick up
  90      */
  91     public int canPickUpDrop(Drop drop) {
  92         for (int i = 0; i < 36; i++) {
  93             final InventoryItem invItem = inventory.get(i);
  94
  95             if (!invItem.getItem().isTool()
  96                     && invItem.getItem() == drop.getItem()
  97                     && invItem.getAmount() < invItem.getItem().getParams().getMaxStack()) {
  98                 return i;
  99             }
 100
 101             if (invItem.getItem().isNone()) {
 102                 return i;
 103             }
 104         }
 105
 106         return -1;
 107     }
 108
 109     public void pickUpDrop(Drop drop) {
 110         int index = canPickUpDrop(drop);
 111
 112         if (index < 0) {
 113             return;
 114         }
 115
 116         final InventoryItem invItem = inventory.get(index);
 117
 118         if (invItem.getItem().equals(drop.getItem())) {
 119             invItem.setAmount(invItem.getAmount() + 1);
 120             drop.setPickedUp(true);
 121         } else if (invItem.getItem().isNone()) {
 122             inventory.set(index, drop.getItem().toInventoryItem());
 123             drop.setPickedUp(true);
 124         }
 125     }
 126
 127     private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
 128         if (spawnPoint != null) {
 129             return spawnPoint;
 130         }
 131
 132         int y, x = gameWorld.getWidth() / 2;
 133         for (y = 0; y <= gameWorld.getWorldConfig().getSeaLevel(); y++) {
 134             if (y == gameWorld.getWorldConfig().getSeaLevel()) {
 135                 for (x = 0; x < gameWorld.getWidth(); x++) {
 136                     if (gameWorld.getForeMap(x, y).getParams().getHasCollision()) {
 137                         break;
 138                     }
 139                     if (x == gameWorld.getWidth() - 1) {
 140                         gameWorld.setForeMap(x, y, itemsHolder.getBlock("grass"));
 141                         break;
 142                     }
 143                 }
 144                 break;
 145             }
 146             if (gameWorld.hasForeAt(x, y) && gameWorld.getForeMap(x, y).hasCollision()) {
 147                 break;
 148             }
 149         }
 150         spawnPoint = new Vector2(x * 16 + 8 - getWidth() / 2, (float) y * 16 - getHeight());
 151         return spawnPoint;
 152     }
 153
 154     public void setDir(Direction dir) {
 155         if (dir != getDirection()) {
 156             switchDir();
 157         }
 158     }
 159
 160     public void setCurrentInventorySlotItem(Item item) {
 161         inventory.set(slot, item.toInventoryItem());
 162     }
 163
 164     @Override
 165     public float getSpeed() {
 166         return SPEED;
 167     }
 168
 169     @Override
 170     public void jump() {
 171         mVelocity.y = JUMP_VELOCITY;
 172     }
 173
 174     private boolean checkBlockCanBeHit(Block block) {
 175         return !block.isNone() && block.getParams().getHitPoints() >= 0;
 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, float delta) {
 216         updateAnimation(delta);
 217         hitBlock(gameWorld, gameItemsHolder);
 218
 219         if (gameMode == 1) {
 220             return;
 221         }
 222
 223         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 224         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 225         @CheckForNull final Block target;
 226
 227         if (checkBlockCanBeHit(foregroundBlock)) {
 228             target = foregroundBlock;
 229         } else if (checkBlockCanBeHit(backgroundBlock)) {
 230             target = backgroundBlock;
 231         } else {
 232             target = null;
 233         }
 234
 235         final boolean canHitBlock = target != null;
 236
 237         float multiplier = 1f;
 238         final Item currentItem = inventory.get(slot).getItem();
 239         if (currentItem instanceof Item.Tool && canHitBlock) {
 240             if (target.getParams().getToolType() == currentItem.getClass()
 241                     && ((Item.Tool)currentItem).getLevel() >= target.getParams().getToolLevel()) {
 242                 multiplier = 2f * ((Item.Tool)currentItem).getLevel();
 243             }
 244             multiplier *= ((Item.Tool)currentItem).getBlockDamageMultiplier();
 245         }
 246
 247         if (hitting && hittingWithDamage && canHitBlock) {
 248             blockDamage += 60f * delta * multiplier;
 249         } else {
 250             blockDamage = 0f;
 251         }
 252     }
 253
 254     @Override
 255     public void changeDir() {
 256     }
 257
 258     @Override
 259     public void damage(int damage) {
 260         if (gameMode == 1) {
 261             return;
 262         }
 263
 264         if (damage > 0) {
 265             getVelocity().y += JUMP_VELOCITY / 3f;
 266         }
 267
 268         super.damage(damage);
 269     }
 270
 271     @Override
 272     public void heal(int heal) {
 273         if (gameMode == 1) {
 274             return;
 275         }
 276         super.heal(heal);
 277     }
 278
 279     private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
 280         final Item item = inventory.get(slot).getItem();
 281
 282         if (item == null || item.isNone()) {
 283             return;
 284         }
 285
 286         final Sprite sprite = item.getSprite();
 287         final boolean smallSprite = !item.isTool() || item.isShears();
 288
 289         final float originalWidth = sprite.getWidth();
 290         final float originalHeight = sprite.getHeight();
 291
 292         if (smallSprite) {
 293             sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
 294         }
 295
 296         final float handLength = Assets.playerSprite[0][2].getHeight();
 297
 298         final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
 299         final int handMultiplier = -getDirection().getBasis();
 300         final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
 301         final float yOffset = !smallSprite ? -sprite.getHeight() / 2 : 0;
 302
 303         float rotate = anim + 30;
 304
 305         if (item.isTool()) {
 306             sprite.rotate90(looksLeft());
 307         }
 308
 309         final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
 310         final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
 311
 312         if (looksLeft()) {
 313             sprite.setFlip(!item.isTool(), sprite.isFlipY());
 314             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
 315         } else {
 316             sprite.setFlip(item.isTool(), sprite.isFlipY());
 317             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
 318         }
 319
 320         sprite.setRotation(-handMultiplier * rotate);
 321         sprite.setPosition(itemX, itemY);
 322         sprite.draw(spriteBatch);
 323
 324         // dont forget to reset
 325         sprite.setFlip(false, sprite.isFlipY());
 326         sprite.setRotation(0);
 327         sprite.setOriginCenter();
 328         sprite.setSize(originalWidth, originalHeight);
 329         if (item.isTool()) {
 330             sprite.rotate90(looksRight());
 331         }
 332     }
 333
 334     public void startHitting(boolean withDamage) {
 335         if (hitting) {
 336             return;
 337         }
 338
 339         hitting = true;
 340         hittingWithDamage = withDamage;
 341         hitAnim = 90f;
 342         hitAnimDelta = ANIMATION_SPEED;
 343     }
 344
 345     public void startHitting() {
 346         startHitting(true);
 347     }
 348
 349     public void stopHitting() {
 350         blockDamage = 0f;
 351         hitting = false;
 352     }
 353
 354     private float getRightHandAnim(float delta) {
 355         hitAnim -= hitAnimDelta * delta;
 356
 357         if (hitAnim < 30f || hitAnim > 90f) {
 358             if (hitting) {
 359                 hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
 360                 hitAnimDelta = -hitAnimDelta;
 361             } else  {
 362                 hitAnimDelta = ANIMATION_SPEED;
 363             }
 364         }
 365
 366         if (!hitting) {
 367             if (hitAnim < hitAnimDelta * delta) {
 368                 hitAnim = 0;
 369                 hitAnimDelta = 0;
 370                 return -mAnim;
 371             }
 372         }
 373
 374         return hitAnim;
 375     }
 376
 377     @Override
 378     public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
 379         final Sprite backHand = Assets.playerSprite[1][2];
 380         final Sprite backLeg = Assets.playerSprite[1][3];
 381         final Sprite frontLeg = Assets.playerSprite[0][3];
 382         final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
 383         final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
 384         final Sprite frontHand = Assets.playerSprite[0][2];
 385
 386         float backHandAnim, frontHandAnim;
 387
 388         final float rightHandAnim = getRightHandAnim(delta);
 389
 390         if (looksLeft()) {
 391             backHandAnim = rightHandAnim;
 392             frontHandAnim = mAnim;
 393         } else {
 394             backHandAnim = -mAnim;
 395             frontHandAnim = -rightHandAnim;
 396         }
 397
 398         SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
 399
 400         if (looksLeft()) {
 401             drawItem(spriteBatch, x, y, -backHandAnim);
 402         }
 403
 404         SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
 405         SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
 406         SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
 407         SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
 408
 409         if (looksRight()) {
 410             drawItem(spriteBatch, x, y, frontHandAnim);
 411         }
 412
 413         SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
 414     }
 415
 416 }