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