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[9];
  42         for (int i = 0; i < 9; 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 pickUpDrop(Drop drop) {
  69         for (int i = 0; i < inventory.length; i++) {
  70             if (inventory(i) == null || inventory(i).getParams().getKey().equals(GameItemsHolder.FALLBACK_ITEM_KEY) || inventory(i) == drop.getItem()) {
  71                 inventory[i] = drop.getItem().toInventoryItem();
  72                 drop.setPickedUp(true);
  73                 break;
  74             }
  75         }
  76     }
  77
  78     private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  79         int y;
  80         for (y = 0; y < gameWorld.getHeight(); y++) {
  81             if (y == gameWorld.getHeight() - 1) {
  82                 y = 60;
  83                 gameWorld.setForeMap(0, y, itemsHolder.getBlock("grass"));
  84                 break;
  85             }
  86             if (gameWorld.hasForeAt(0, y) && gameWorld.getForeMap(0, y).hasCollision()) {
  87                 break;
  88             }
  89         }
  90         return new Vector2(8 - getWidth() / 2, (float) y * 16 - getHeight());
  91     }
  92
  93     public void setDir(Direction dir) {
  94         if (dir != getDirection()) {
  95             switchDir();
  96         }
  97     }
  98
  99     public void setCurrentInventorySlotItem(Item item) {
 100         inventory[slot] = item.toInventoryItem();
 101     }
 102
 103     @Override
 104     public float getSpeed() {
 105         return SPEED;
 106     }
 107
 108     @Override
 109     public void jump() {
 110         mVelocity.y = JUMP_VELOCITY;
 111     }
 112
 113     @Override
 114     public void ai(GameWorld gameWorld, GameItemsHolder gameItemsHolder, float delta) {
 115         if (gameMode == 1) {
 116             return;
 117         }
 118
 119         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 120         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 121
 122         final boolean canHitBlock = !foregroundBlock.isNone() && foregroundBlock.getParams().getHitPoints() >= 0
 123                 || !backgroundBlock.isNone() && backgroundBlock.getParams().getHitPoints() >= 0;
 124
 125         if (hitting && canHitBlock) {
 126             blockDamage += 60f * delta;
 127         } else {
 128             blockDamage = 0f;
 129         }
 130     }
 131
 132     @Override
 133     public void changeDir() {
 134     }
 135
 136     @Override
 137     public void damage(int damage) {
 138         if (gameMode == 1) {
 139             return;
 140         }
 141         super.damage(damage);
 142     }
 143
 144     @Override
 145     public void heal(int heal) {
 146         if (gameMode == 1) {
 147             return;
 148         }
 149         super.heal(heal);
 150     }
 151
 152     private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
 153         final Item item = inventory(slot);
 154
 155         if (item == null || item.isNone()) {
 156             return;
 157         }
 158
 159         final Sprite sprite = item.getSprite();
 160
 161         if (!item.isTool()) {
 162             sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
 163         }
 164
 165         final float handLength = Assets.playerSprite[0][2].getHeight();
 166
 167         final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
 168         final int handMultiplier = -getDirection().getBasis();
 169         final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
 170         final float yOffset = item.isTool() ? -sprite.getHeight() / 2 : 0;
 171
 172         float rotate = anim + 30;
 173
 174         final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
 175         final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
 176
 177         if (looksLeft()) {
 178             sprite.setFlip(true, sprite.isFlipY());
 179             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
 180         } else {
 181             sprite.setFlip(false, sprite.isFlipY());
 182             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
 183         }
 184
 185         SpriteUtilsKt.drawSprite(spriteBatch, sprite, itemX, itemY, -handMultiplier * rotate);
 186
 187         // dont forget to reset
 188         sprite.setFlip(false, sprite.isFlipY());
 189         sprite.setRotation(0);
 190         sprite.setOriginCenter();
 191     }
 192
 193     public void startHitting() {
 194         if (hitting) {
 195             return;
 196         }
 197
 198         hitting = true;
 199         hitAnim = 90f;
 200         hitAnimDelta = ANIMATION_SPEED;
 201     }
 202
 203     public void stopHitting() {
 204         blockDamage = 0f;
 205         hitting = false;
 206     }
 207
 208     private float getRightHandAnim(float delta) {
 209         hitAnim -= hitAnimDelta * delta;
 210
 211         if (hitAnim < 30f || hitAnim > 90f) {
 212             if (hitting) {
 213                 hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
 214                 hitAnimDelta = -hitAnimDelta;
 215             } else  {
 216                 hitAnimDelta = ANIMATION_SPEED;
 217             }
 218         }
 219
 220         if (!hitting) {
 221             if (hitAnim < hitAnimDelta * delta) {
 222                 hitAnim = 0;
 223                 hitAnimDelta = 0;
 224                 return -mAnim;
 225             }
 226         }
 227
 228         return hitAnim;
 229     }
 230
 231     @Override
 232     public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
 233         updateAnimation(delta);
 234
 235         final Sprite backHand = Assets.playerSprite[1][2];
 236         final Sprite backLeg = Assets.playerSprite[1][3];
 237         final Sprite frontLeg = Assets.playerSprite[0][3];
 238         final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
 239         final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
 240         final Sprite frontHand = Assets.playerSprite[0][2];
 241
 242         float backHandAnim, frontHandAnim;
 243
 244         final float rightHandAnim = getRightHandAnim(delta);
 245
 246         if (looksLeft()) {
 247             backHandAnim = rightHandAnim;
 248             frontHandAnim = mAnim;
 249         } else {
 250             backHandAnim = -mAnim;
 251             frontHandAnim = -rightHandAnim;
 252         }
 253
 254         SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
 255
 256         if (looksLeft()) {
 257             drawItem(spriteBatch, x, y, -backHandAnim);
 258         }
 259
 260         SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
 261         SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
 262         SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
 263         SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
 264
 265         if (looksRight()) {
 266             drawItem(spriteBatch, x, y, frontHandAnim);
 267         }
 268
 269         SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
 270     }
 271
 272 }