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