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     @CheckForNull
  66     public Item inventory(int i) {
  67         return inventory.get(i).getItem();
  68     }
  69
  70     public void respawn(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  71         Vector2 pos = getSpawnPoint(gameWorld, itemsHolder);
  72         this.x = pos.x;
  73         this.y = pos.y;
  74         mVelocity.setZero();
  75         mDead = false;
  76         heal(MAX_HEALTH);
  77     }
  78
  79     public void decreaseCurrentItemCount(GameItemsHolder gameItemsHolder) {
  80         if (gameMode == 1) {
  81             return;
  82         }
  83         getCurrentItem().setAmount(getCurrentItem().getAmount() - 1);
  84         if (getCurrentItem().getAmount() <= 0) {
  85             setCurrentInventorySlotItem(gameItemsHolder.getFallbackItem());
  86         }
  87     }
  88
  89     public InventoryItem getCurrentItem() {
  90         return inventory.get(slot);
  91     }
  92
  93     public void pickUpDrop(Drop drop) {
  94         for (InventoryItem invItem : inventory) {
  95             if (!invItem.getItem().isTool()
  96                     && invItem.getItem() == drop.getItem()
  97                     && invItem.getAmount() < invItem.getItem().getParams().getMaxStack()) {
  98                 invItem.setAmount(invItem.getAmount() + 1);
  99                 drop.setPickedUp(true);
 100                 return;
 101             }
 102         }
 103
 104         for (int i = 0; i < inventory.size(); i++) {
 105             if (inventory(i) == null || inventory(i).getParams().getKey().equals(GameItemsHolder.FALLBACK_ITEM_KEY)) {
 106                 inventory.set(i, drop.getItem().toInventoryItem());
 107                 drop.setPickedUp(true);
 108                 break;
 109             }
 110         }
 111     }
 112
 113     private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
 114         if (spawnPoint != null) {
 115             return spawnPoint;
 116         }
 117
 118         int y, x = gameWorld.getWidth() / 2;
 119         for (y = 0; y <= gameWorld.getWorldConfig().getSeaLevel(); y++) {
 120             if (y == gameWorld.getWorldConfig().getSeaLevel()) {
 121                 for (x = 0; x < gameWorld.getWidth(); x++) {
 122                     if (gameWorld.getForeMap(x, y).getParams().getHasCollision()) {
 123                         break;
 124                     }
 125                     if (x == gameWorld.getWidth() - 1) {
 126                         gameWorld.setForeMap(x, y, itemsHolder.getBlock("grass"));
 127                         break;
 128                     }
 129                 }
 130                 break;
 131             }
 132             if (gameWorld.hasForeAt(x, y) && gameWorld.getForeMap(x, y).hasCollision()) {
 133                 break;
 134             }
 135         }
 136         spawnPoint = new Vector2(x * 16 + 8 - getWidth() / 2, (float) y * 16 - getHeight());
 137         return spawnPoint;
 138     }
 139
 140     public void setDir(Direction dir) {
 141         if (dir != getDirection()) {
 142             switchDir();
 143         }
 144     }
 145
 146     public void setCurrentInventorySlotItem(Item item) {
 147         inventory.set(slot, item.toInventoryItem());
 148     }
 149
 150     @Override
 151     public float getSpeed() {
 152         return SPEED;
 153     }
 154
 155     @Override
 156     public void jump() {
 157         mVelocity.y = JUMP_VELOCITY;
 158     }
 159
 160     private boolean checkBlockCanBeHit(Block block) {
 161         return !block.isNone() && block.getParams().getHitPoints() >= 0;
 162     }
 163
 164     private void hitBlock(GameWorld gameWorld, GameItemsHolder gameItemsHolder) {
 165         if (!hitting || !hittingWithDamage) {
 166             return;
 167         }
 168
 169         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 170         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 171
 172
 173         if ((checkBlockCanBeHit(foregroundBlock)) ||
 174                 (foregroundBlock.isNone() && checkBlockCanBeHit(backgroundBlock))) {
 175             if (gameMode == 0) {
 176                 if (!foregroundBlock.isNone()) {
 177                     if (blockDamage >= foregroundBlock.getParams().getHitPoints()) {
 178                         gameWorld.destroyForeMap(cursorX, cursorY);
 179                         blockDamage = 0;
 180                     }
 181                 } else if (!backgroundBlock.isNone()) {
 182                     if (blockDamage >= backgroundBlock.getParams().getHitPoints()) {
 183                         gameWorld.destroyBackMap(cursorX, cursorY);
 184                         blockDamage = 0;
 185                     }
 186                 }
 187             } else {
 188                 if (!foregroundBlock.isNone()) {
 189                     gameWorld.placeToForeground(cursorX, cursorY, gameItemsHolder.getFallbackBlock());
 190                 } else if (!backgroundBlock.isNone()) {
 191                     gameWorld.placeToBackground(cursorX, cursorY, gameItemsHolder.getFallbackBlock());
 192                 }
 193                 stopHitting();
 194             }
 195         } else {
 196             stopHitting();
 197         }
 198     }
 199
 200     @Override
 201     public void ai(GameWorld gameWorld, GameItemsHolder gameItemsHolder, float delta) {
 202         updateAnimation(delta);
 203         hitBlock(gameWorld, gameItemsHolder);
 204
 205         if (gameMode == 1) {
 206             return;
 207         }
 208
 209         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 210         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 211         @CheckForNull final Block target;
 212
 213         if (checkBlockCanBeHit(foregroundBlock)) {
 214             target = foregroundBlock;
 215         } else if (checkBlockCanBeHit(backgroundBlock)) {
 216             target = backgroundBlock;
 217         } else {
 218             target = null;
 219         }
 220
 221         final boolean canHitBlock = target != null;
 222
 223         float multiplier = 1f;
 224         final Item currentItem = inventory.get(slot).getItem();
 225         if (currentItem instanceof Item.Tool && canHitBlock) {
 226             if (target.getParams().getToolType() == currentItem.getClass()
 227                     && ((Item.Tool)currentItem).getLevel() >= target.getParams().getToolLevel()) {
 228                 multiplier = 2f * ((Item.Tool)currentItem).getLevel();
 229             }
 230             multiplier *= ((Item.Tool)currentItem).getBlockDamageMultiplier();
 231         }
 232
 233         if (hitting && hittingWithDamage && canHitBlock) {
 234             blockDamage += 60f * delta * multiplier;
 235         } else {
 236             blockDamage = 0f;
 237         }
 238     }
 239
 240     @Override
 241     public void changeDir() {
 242     }
 243
 244     @Override
 245     public void damage(int damage) {
 246         if (gameMode == 1) {
 247             return;
 248         }
 249
 250         if (damage > 0) {
 251             getVelocity().y += JUMP_VELOCITY / 3f;
 252         }
 253
 254         super.damage(damage);
 255     }
 256
 257     @Override
 258     public void heal(int heal) {
 259         if (gameMode == 1) {
 260             return;
 261         }
 262         super.heal(heal);
 263     }
 264
 265     private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
 266         final Item item = inventory(slot);
 267
 268         if (item == null || item.isNone()) {
 269             return;
 270         }
 271
 272         final Sprite sprite = item.getSprite();
 273         final boolean smallSprite = !item.isTool() || item.isShears();
 274
 275         final float originalWidth = sprite.getWidth();
 276         final float originalHeight = sprite.getHeight();
 277
 278         if (smallSprite) {
 279             sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
 280         }
 281
 282         final float handLength = Assets.playerSprite[0][2].getHeight();
 283
 284         final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
 285         final int handMultiplier = -getDirection().getBasis();
 286         final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
 287         final float yOffset = !smallSprite ? -sprite.getHeight() / 2 : 0;
 288
 289         float rotate = anim + 30;
 290
 291         if (item.isTool()) {
 292             sprite.rotate90(looksLeft());
 293         }
 294
 295         final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
 296         final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
 297
 298         if (looksLeft()) {
 299             sprite.setFlip(!item.isTool(), sprite.isFlipY());
 300             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
 301         } else {
 302             sprite.setFlip(item.isTool(), sprite.isFlipY());
 303             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
 304         }
 305
 306         sprite.setRotation(-handMultiplier * rotate);
 307         sprite.setPosition(itemX, itemY);
 308         sprite.draw(spriteBatch);
 309
 310         // dont forget to reset
 311         sprite.setFlip(false, sprite.isFlipY());
 312         sprite.setRotation(0);
 313         sprite.setOriginCenter();
 314         sprite.setSize(originalWidth, originalHeight);
 315         if (item.isTool()) {
 316             sprite.rotate90(looksRight());
 317         }
 318     }
 319
 320     public void startHitting(boolean withDamage) {
 321         if (hitting) {
 322             return;
 323         }
 324
 325         hitting = true;
 326         hittingWithDamage = withDamage;
 327         hitAnim = 90f;
 328         hitAnimDelta = ANIMATION_SPEED;
 329     }
 330
 331     public void startHitting() {
 332         startHitting(true);
 333     }
 334
 335     public void stopHitting() {
 336         blockDamage = 0f;
 337         hitting = false;
 338     }
 339
 340     private float getRightHandAnim(float delta) {
 341         hitAnim -= hitAnimDelta * delta;
 342
 343         if (hitAnim < 30f || hitAnim > 90f) {
 344             if (hitting) {
 345                 hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
 346                 hitAnimDelta = -hitAnimDelta;
 347             } else  {
 348                 hitAnimDelta = ANIMATION_SPEED;
 349             }
 350         }
 351
 352         if (!hitting) {
 353             if (hitAnim < hitAnimDelta * delta) {
 354                 hitAnim = 0;
 355                 hitAnimDelta = 0;
 356                 return -mAnim;
 357             }
 358         }
 359
 360         return hitAnim;
 361     }
 362
 363     @Override
 364     public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
 365         final Sprite backHand = Assets.playerSprite[1][2];
 366         final Sprite backLeg = Assets.playerSprite[1][3];
 367         final Sprite frontLeg = Assets.playerSprite[0][3];
 368         final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
 369         final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
 370         final Sprite frontHand = Assets.playerSprite[0][2];
 371
 372         float backHandAnim, frontHandAnim;
 373
 374         final float rightHandAnim = getRightHandAnim(delta);
 375
 376         if (looksLeft()) {
 377             backHandAnim = rightHandAnim;
 378             frontHandAnim = mAnim;
 379         } else {
 380             backHandAnim = -mAnim;
 381             frontHandAnim = -rightHandAnim;
 382         }
 383
 384         SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
 385
 386         if (looksLeft()) {
 387             drawItem(spriteBatch, x, y, -backHandAnim);
 388         }
 389
 390         SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
 391         SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
 392         SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
 393         SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
 394
 395         if (looksRight()) {
 396             drawItem(spriteBatch, x, y, frontHandAnim);
 397         }
 398
 399         SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
 400     }
 401
 402 }