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.item.InventoryItem;
   9 import ru.deadsoftware.cavedroid.game.model.item.Item;
  10 import ru.deadsoftware.cavedroid.game.objects.Drop;
  11 import ru.deadsoftware.cavedroid.game.world.GameWorld;
  12 import ru.deadsoftware.cavedroid.misc.Assets;
  13 import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin;
  14 import ru.deadsoftware.cavedroid.misc.utils.SpriteUtilsKt;
  15
  16 import javax.annotation.CheckForNull;
  17
  18 public class Player extends Mob {
  19
  20     private static final float SPEED = 69.072f;
  21     private static final float JUMP_VELOCITY = -133.332f;
  22     private static final int MAX_HEALTH = 20;
  23
  24     private boolean hitting = false;
  25     private float hitAnim = 0f;
  26     private float hitAnimDelta = ANIMATION_SPEED;
  27
  28     public final InventoryItem[] inventory;
  29     public int slot;
  30     public int gameMode;
  31     public boolean swim;
  32     public float headRotation = 0f;
  33
  34     public Player(GameItemsHolder gameItemsHolder) {
  35         super(0, 0, 4, 30, randomDir(), Type.MOB, MAX_HEALTH);
  36         inventory = new InventoryItem[9];
  37         for (int i = 0; i < 9; i++) {
  38             inventory[i] = gameItemsHolder.getFallbackItem().toInventoryItem();
  39         }
  40         swim = false;
  41     }
  42
  43     public void initInventory(GameItemsHolder gameItemsHolder) {
  44         for (InventoryItem invItem : inventory) {
  45             invItem.init(gameItemsHolder);
  46         }
  47     }
  48
  49     @CheckForNull
  50     public Item inventory(int i) {
  51         return inventory[i].getItem();
  52     }
  53
  54     public void respawn(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  55         Vector2 pos = getSpawnPoint(gameWorld, itemsHolder);
  56         this.x = pos.x;
  57         this.y = pos.y;
  58         mVelocity.setZero();
  59         mDead = false;
  60         heal(MAX_HEALTH);
  61     }
  62
  63     public void pickUpDrop(Drop drop) {
  64         for (int i = 0; i < inventory.length; i++) {
  65             if (inventory(i) == null || inventory(i).getParams().getKey().equals(GameItemsHolder.FALLBACK_ITEM_KEY) || inventory(i) == drop.getItem()) {
  66                 inventory[i] = drop.getItem().toInventoryItem();
  67                 drop.setPickedUp(true);
  68                 break;
  69             }
  70         }
  71     }
  72
  73     private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  74         int y;
  75         for (y = 0; y < gameWorld.getHeight(); y++) {
  76             if (y == gameWorld.getHeight() - 1) {
  77                 y = 60;
  78                 gameWorld.setForeMap(0, y, itemsHolder.getBlock("grass"));
  79                 break;
  80             }
  81             if (gameWorld.hasForeAt(0, y) && gameWorld.getForeMap(0, y).hasCollision()) {
  82                 break;
  83             }
  84         }
  85         return new Vector2(8 - getWidth() / 2, (float) y * 16 - getHeight());
  86     }
  87
  88     public void setDir(Direction dir) {
  89         if (dir != getDirection()) {
  90             switchDir();
  91         }
  92     }
  93
  94     public void setCurrentInventorySlotItem(Item item) {
  95         inventory[slot] = item.toInventoryItem();
  96     }
  97
  98     @Override
  99     public float getSpeed() {
 100         return SPEED;
 101     }
 102
 103     @Override
 104     public void jump() {
 105         mVelocity.y = JUMP_VELOCITY;
 106     }
 107
 108     @Override
 109     public void ai(GameWorld gameWorld, GameItemsHolder gameItemsHolder, float delta) {
 110     }
 111
 112     @Override
 113     public void changeDir() {
 114     }
 115
 116     @Override
 117     public void damage(int damage) {
 118         if (gameMode == 1) {
 119             return;
 120         }
 121         super.damage(damage);
 122     }
 123
 124     @Override
 125     public void heal(int heal) {
 126         if (gameMode == 1) {
 127             return;
 128         }
 129         super.heal(heal);
 130     }
 131
 132     private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
 133         final Item item = inventory(slot);
 134
 135         if (item == null || item.isNone()) {
 136             return;
 137         }
 138
 139         final Sprite sprite = item.getSprite();
 140
 141         if (!item.isTool()) {
 142             sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
 143         }
 144
 145         final float handLength = Assets.playerSprite[0][2].getHeight();
 146
 147         final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
 148         final int handMultiplier = -getDirection().getBasis();
 149         final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
 150         final float yOffset = item.isTool() ? -sprite.getHeight() / 2 : 0;
 151
 152         float rotate = anim + 30;
 153
 154         final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
 155         final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
 156
 157         if (looksLeft()) {
 158             sprite.setFlip(true, sprite.isFlipY());
 159             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
 160         } else {
 161             sprite.setFlip(false, sprite.isFlipY());
 162             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
 163         }
 164
 165         SpriteUtilsKt.drawSprite(spriteBatch, sprite, itemX, itemY, -handMultiplier * rotate);
 166
 167         // dont forget to reset
 168         sprite.setFlip(false, sprite.isFlipY());
 169         sprite.setRotation(0);
 170         sprite.setOriginCenter();
 171     }
 172
 173     public void startHitting() {
 174         if (hitting) {
 175             return;
 176         }
 177
 178         hitting = true;
 179         hitAnim = 90f;
 180         hitAnimDelta = ANIMATION_SPEED;
 181     }
 182
 183     public void stopHitting() {
 184         hitting = false;
 185     }
 186
 187     private float getRightHandAnim(float delta) {
 188         hitAnim -= hitAnimDelta * delta;
 189
 190         if (hitAnim < 30f || hitAnim > 90f) {
 191             if (hitting) {
 192                 hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
 193                 hitAnimDelta = -hitAnimDelta;
 194             } else  {
 195                 hitAnimDelta = ANIMATION_SPEED;
 196             }
 197         }
 198
 199         if (!hitting) {
 200             if (hitAnim < hitAnimDelta * delta) {
 201                 hitAnim = 0;
 202                 hitAnimDelta = 0;
 203                 return -mAnim;
 204             }
 205         }
 206
 207         return hitAnim;
 208     }
 209
 210     @Override
 211     public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
 212         updateAnimation(delta);
 213
 214         final Sprite backHand = Assets.playerSprite[1][2];
 215         final Sprite backLeg = Assets.playerSprite[1][3];
 216         final Sprite frontLeg = Assets.playerSprite[0][3];
 217         final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
 218         final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
 219         final Sprite frontHand = Assets.playerSprite[0][2];
 220
 221         float backHandAnim, frontHandAnim;
 222
 223         final float rightHandAnim = getRightHandAnim(delta);
 224
 225         if (looksLeft()) {
 226             backHandAnim = rightHandAnim;
 227             frontHandAnim = mAnim;
 228         } else {
 229             backHandAnim = -mAnim;
 230             frontHandAnim = -rightHandAnim;
 231         }
 232
 233         SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
 234
 235         if (looksLeft()) {
 236             drawItem(spriteBatch, x, y, -backHandAnim);
 237         }
 238
 239         SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
 240         SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
 241         SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
 242         SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
 243
 244         if (looksRight()) {
 245             drawItem(spriteBatch, x, y, frontHandAnim);
 246         }
 247
 248         SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
 249     }
 250
 251 }