core/src/ru/deadsoftware/cavedroid/game/mobs/player/Player.java

   1 package ru.deadsoftware.cavedroid.game.mobs.player;
   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.mobs.Mob;
   9 import ru.deadsoftware.cavedroid.game.model.block.Block;
  10 import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
  11 import ru.deadsoftware.cavedroid.game.model.item.Item;
  12 import ru.deadsoftware.cavedroid.game.objects.Drop;
  13 import ru.deadsoftware.cavedroid.game.objects.DropController;
  14 import ru.deadsoftware.cavedroid.game.ui.TooltipManager;
  15 import ru.deadsoftware.cavedroid.game.world.GameWorld;
  16 import ru.deadsoftware.cavedroid.misc.Assets;
  17 import ru.deadsoftware.cavedroid.misc.utils.SpriteOrigin;
  18 import ru.deadsoftware.cavedroid.misc.utils.SpriteUtilsKt;
  19
  20 import javax.annotation.CheckForNull;
  21
  22 public class Player extends Mob {
  23
  24     private static final float SPEED = 69.072f;
  25     private static final float JUMP_VELOCITY = -133.332f;
  26     private static final int SURVIVAL_CURSOR_RANGE = 4;
  27
  28     public static final int MAX_HEALTH = 20;
  29     public static final int INVENTORY_SIZE = 36;
  30     public static final int HOTBAR_SIZE = 9;
  31
  32     private boolean hitting = false, hittingWithDamage = false;
  33     private float hitAnim = 0f;
  34     private float hitAnimDelta = ANIMATION_SPEED;
  35
  36     public final Inventory inventory;
  37
  38     public int gameMode;
  39     public boolean swim;
  40     public float headRotation = 0f;
  41
  42     public float blockDamage = 0f;
  43     public int cursorX = 0;
  44     public int cursorY = 0;
  45
  46     @CheckForNull
  47     private Vector2 spawnPoint = null;
  48
  49     public ControlMode controlMode = ControlMode.WALK;
  50
  51     public enum ControlMode {
  52         WALK,
  53         CURSOR
  54     }
  55
  56     public Player(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
  57         super(0, 0, 4, 30, randomDir(), Type.MOB, MAX_HEALTH);
  58         inventory = new Inventory(INVENTORY_SIZE, HOTBAR_SIZE, gameItemsHolder, tooltipManager);
  59         swim = false;
  60     }
  61
  62     public void initInventory(GameItemsHolder gameItemsHolder, TooltipManager tooltipManager) {
  63         inventory.initItems(gameItemsHolder, tooltipManager);
  64     }
  65
  66     public void respawn(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  67         Vector2 pos = getSpawnPoint(gameWorld, itemsHolder);
  68         this.x = pos.x;
  69         this.y = pos.y;
  70         mVelocity.setZero();
  71         mDead = false;
  72         heal(MAX_HEALTH);
  73     }
  74
  75     public void decreaseCurrentItemCount(GameItemsHolder gameItemsHolder) {
  76         if (gameMode == 1) {
  77             return;
  78         }
  79
  80         final InventoryItem item = inventory.getActiveItem();
  81         item.subtract();
  82         if (item.getAmount() <= 0) {
  83             setCurrentInventorySlotItem(gameItemsHolder.getFallbackItem());
  84         }
  85     }
  86
  87     public void dropCurrentItem(DropController dropController) {
  88         final InventoryItem activeItem = inventory.getActiveItem();
  89
  90     }
  91
  92     private Vector2 getSpawnPoint(GameWorld gameWorld, GameItemsHolder itemsHolder) {
  93         if (spawnPoint != null) {
  94             return spawnPoint;
  95         }
  96
  97         int y, x = gameWorld.getWidth() / 2;
  98         for (y = 0; y <= gameWorld.getWorldConfig().getSeaLevel(); y++) {
  99             if (y == gameWorld.getWorldConfig().getSeaLevel()) {
 100                 for (x = 0; x < gameWorld.getWidth(); x++) {
 101                     if (gameWorld.getForeMap(x, y).getParams().getHasCollision()) {
 102                         break;
 103                     }
 104                     if (x == gameWorld.getWidth() - 1) {
 105                         gameWorld.setForeMap(x, y, itemsHolder.getBlock("grass"));
 106                         break;
 107                     }
 108                 }
 109                 break;
 110             }
 111             if (gameWorld.hasForeAt(x, y) && gameWorld.getForeMap(x, y).hasCollision()) {
 112                 break;
 113             }
 114         }
 115         spawnPoint = new Vector2(x * 16 + 8 - getWidth() / 2, (float) y * 16 - getHeight());
 116         return spawnPoint;
 117     }
 118
 119     public void setDir(Direction dir) {
 120         if (dir != getDirection()) {
 121             switchDir();
 122         }
 123     }
 124
 125     public void setCurrentInventorySlotItem(Item item) {
 126         inventory.getItems().set(inventory.getActiveSlot(), item.toInventoryItem());
 127     }
 128
 129     @Override
 130     public float getSpeed() {
 131         return SPEED;
 132     }
 133
 134     @Override
 135     public void jump() {
 136         if (!canJump()) {
 137             if (gameMode == 1) {
 138                 if (isFlyMode()) {
 139                     setFlyMode(false);
 140                 } else {
 141                     getVelocity().y = 0f;
 142                     setFlyMode(true);
 143                 }
 144             }
 145             return;
 146         }
 147         mVelocity.y = JUMP_VELOCITY;
 148     }
 149
 150     private boolean checkBlockCanBeHit(Block block) {
 151         return !block.isNone() && block.getParams().getHitPoints() >= 0;
 152     }
 153
 154     private void hitBlock(GameWorld gameWorld, GameItemsHolder gameItemsHolder) {
 155         if (!hitting || !hittingWithDamage) {
 156             return;
 157         }
 158
 159         final Block foregroundBlock = gameWorld.getForeMap(cursorX, cursorY);
 160         final Block backgroundBlock = gameWorld.getBackMap(cursorX, cursorY);
 161
 162
 163         if ((checkBlockCanBeHit(foregroundBlock)) ||
 164                 (foregroundBlock.isNone() && checkBlockCanBeHit(backgroundBlock))) {
 165             if (gameMode == 0) {
 166                 if (!foregroundBlock.isNone()) {
 167                     if (blockDamage >= foregroundBlock.getParams().getHitPoints()) {
 168                         gameWorld.destroyForeMap(cursorX, cursorY);
 169                         blockDamage = 0;
 170                     }
 171                 } else if (!backgroundBlock.isNone()) {
 172                     if (blockDamage >= backgroundBlock.getParams().getHitPoints()) {
 173                         gameWorld.destroyBackMap(cursorX, cursorY);
 174                         blockDamage = 0;
 175                     }
 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 (checkBlockCanBeHit(foregroundBlock)) {
 204             target = foregroundBlock;
 205         } else if (checkBlockCanBeHit(backgroundBlock)) {
 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.getActiveItem().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     public void checkCursorBounds(GameWorld gameWorld) {
 256         if (gameMode == 0) {
 257             int minCursorX = getMapX() - SURVIVAL_CURSOR_RANGE;
 258             int maxCursorX = getMapX() + SURVIVAL_CURSOR_RANGE;
 259             int minCursorY = getMiddleMapY() - SURVIVAL_CURSOR_RANGE;
 260             int maxCursorY = getMiddleMapY() + SURVIVAL_CURSOR_RANGE;
 261
 262             cursorX = MathUtils.clamp(cursorX, minCursorX, maxCursorX);
 263             cursorY = MathUtils.clamp(cursorY, minCursorY, maxCursorY);
 264         }
 265
 266         cursorY = MathUtils.clamp(cursorY, 0, gameWorld.getHeight() - 1);
 267     }
 268
 269     private void drawItem(SpriteBatch spriteBatch, float x, float y, float anim) {
 270         final Item item = inventory.getActiveItem().getItem();
 271
 272         if (item == null || item.isNone()) {
 273             return;
 274         }
 275
 276         final Sprite sprite = item.getSprite();
 277         final boolean smallSprite = !item.isTool() || item.isShears();
 278
 279         final float originalWidth = sprite.getWidth();
 280         final float originalHeight = sprite.getHeight();
 281
 282         if (smallSprite) {
 283             sprite.setSize(Drop.DROP_SIZE, Drop.DROP_SIZE);
 284         }
 285
 286         final float handLength = Assets.playerSprite[0][2].getHeight();
 287
 288         final SpriteOrigin spriteOrigin = item.getParams().getInHandSpriteOrigin();
 289         final int handMultiplier = -getDirection().getBasis();
 290         final float xOffset = (-1 + getDirection().getIndex()) * sprite.getWidth() + 4 + handMultiplier * (sprite.getWidth() * spriteOrigin.getX());
 291         final float yOffset = !smallSprite ? -sprite.getHeight() / 2 : 0;
 292
 293         float rotate = anim + 30;
 294
 295         if (item.isTool()) {
 296             sprite.rotate90(looksLeft());
 297         }
 298
 299         final float itemX = x + handLength * MathUtils.sin(handMultiplier * anim * MathUtils.degRad) + xOffset;
 300         final float itemY = y + handLength * MathUtils.cos(handMultiplier * anim * MathUtils.degRad) + yOffset;
 301
 302         if (looksLeft()) {
 303             sprite.setFlip(!item.isTool(), sprite.isFlipY());
 304             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin.getFlipped(true, false));
 305         } else {
 306             sprite.setFlip(item.isTool(), sprite.isFlipY());
 307             SpriteUtilsKt.applyOrigin(sprite, spriteOrigin);
 308         }
 309
 310         sprite.setRotation(-handMultiplier * rotate);
 311         sprite.setPosition(itemX, itemY);
 312         sprite.draw(spriteBatch);
 313
 314         // dont forget to reset
 315         sprite.setFlip(false, sprite.isFlipY());
 316         sprite.setRotation(0);
 317         sprite.setOriginCenter();
 318         sprite.setSize(originalWidth, originalHeight);
 319         if (item.isTool()) {
 320             sprite.rotate90(looksRight());
 321         }
 322     }
 323
 324     public void startHitting(boolean withDamage) {
 325         if (hitting) {
 326             return;
 327         }
 328
 329         hitting = true;
 330         hittingWithDamage = withDamage;
 331         hitAnim = 90f;
 332         hitAnimDelta = ANIMATION_SPEED;
 333     }
 334
 335     public void startHitting() {
 336         startHitting(true);
 337     }
 338
 339     public void stopHitting() {
 340         blockDamage = 0f;
 341         hitting = false;
 342     }
 343
 344     private float getRightHandAnim(float delta) {
 345         hitAnim -= hitAnimDelta * delta;
 346
 347         if (hitAnim < 30f || hitAnim > 90f) {
 348             if (hitting) {
 349                 hitAnim = MathUtils.clamp(hitAnim, 30f, 90f);
 350                 hitAnimDelta = -hitAnimDelta;
 351             } else  {
 352                 hitAnimDelta = ANIMATION_SPEED;
 353             }
 354         }
 355
 356         if (!hitting) {
 357             if (hitAnim < hitAnimDelta * delta) {
 358                 hitAnim = 0;
 359                 hitAnimDelta = 0;
 360                 return -mAnim;
 361             }
 362         }
 363
 364         return hitAnim;
 365     }
 366
 367     @Override
 368     public void draw(SpriteBatch spriteBatch, float x, float y, float delta) {
 369         final Sprite backHand = Assets.playerSprite[1][2];
 370         final Sprite backLeg = Assets.playerSprite[1][3];
 371         final Sprite frontLeg = Assets.playerSprite[0][3];
 372         final Sprite head = Assets.playerSprite[getDirection().getIndex()][0];
 373         final Sprite body = Assets.playerSprite[getDirection().getIndex()][1];
 374         final Sprite frontHand = Assets.playerSprite[0][2];
 375
 376         float backHandAnim, frontHandAnim;
 377
 378         final float rightHandAnim = getRightHandAnim(delta);
 379
 380         if (looksLeft()) {
 381             backHandAnim = rightHandAnim;
 382             frontHandAnim = mAnim;
 383         } else {
 384             backHandAnim = -mAnim;
 385             frontHandAnim = -rightHandAnim;
 386         }
 387
 388         SpriteUtilsKt.drawSprite(spriteBatch, backHand, x + 2, y + 8, backHandAnim);
 389
 390         if (looksLeft()) {
 391             drawItem(spriteBatch, x, y, -backHandAnim);
 392         }
 393
 394         SpriteUtilsKt.drawSprite(spriteBatch, backLeg, x + 2, y + 20, mAnim);
 395         SpriteUtilsKt.drawSprite(spriteBatch, frontLeg, x + 2, y + 20, -mAnim);
 396         SpriteUtilsKt.drawSprite(spriteBatch, head, x, y, headRotation);
 397         SpriteUtilsKt.drawSprite(spriteBatch, body, x + 2, y + 8);
 398
 399         if (looksRight()) {
 400             drawItem(spriteBatch, x, y, frontHandAnim);
 401         }
 402
 403         SpriteUtilsKt.drawSprite(spriteBatch, frontHand, x + 2, y + 8, frontHandAnim);
 404     }
 405
 406 }