core/src/ru/deadsoftware/cavedroid/game/world/GameWorld.java

   1 package ru.deadsoftware.cavedroid.game.world;
   2
   3 import kotlin.Pair;
   4 import ru.deadsoftware.cavedroid.game.GameItemsHolder;
   5 import ru.deadsoftware.cavedroid.game.GameScope;
   6 import ru.deadsoftware.cavedroid.game.mobs.MobsController;
   7 import ru.deadsoftware.cavedroid.game.model.block.Block;
   8 import ru.deadsoftware.cavedroid.game.model.item.InventoryItem;
   9 import ru.deadsoftware.cavedroid.game.model.item.Item;
  10 import ru.deadsoftware.cavedroid.game.model.world.generator.WorldGeneratorConfig;
  11 import ru.deadsoftware.cavedroid.game.objects.DropController;
  12 import ru.deadsoftware.cavedroid.misc.utils.MeasureUnitsUtilsKt;
  13
  14 import javax.annotation.CheckForNull;
  15 import javax.inject.Inject;
  16
  17 @GameScope
  18 public class GameWorld {
  19
  20     private final DropController mDropController;
  21     private final MobsController mMobsController;
  22     private final GameItemsHolder mGameItemsHolder;
  23
  24     private final int mWidth;
  25     private final int mHeight;
  26     private final Block[][] mForeMap;
  27     private final Block[][] mBackMap;
  28
  29     @Inject
  30     public GameWorld(DropController dropController,
  31                      MobsController mobsController,
  32                      GameItemsHolder gameItemsHolder,
  33                      @CheckForNull Block[][] foreMap,
  34                      @CheckForNull Block[][] backMap) {
  35         mDropController = dropController;
  36         mMobsController = mobsController;
  37         mGameItemsHolder = gameItemsHolder;
  38
  39         boolean isNewGame = foreMap == null || backMap == null;
  40
  41         if (isNewGame) {
  42             final WorldGeneratorConfig config = WorldGeneratorConfig.Companion.getDefault();
  43             mWidth = config.getWidth();
  44             mHeight = config.getHeight();
  45             Pair<Block[][], Block[][]> maps = new GameWorldGenerator(config, mGameItemsHolder).generate();
  46             mForeMap = maps.getFirst();
  47             mBackMap = maps.getSecond();
  48             mMobsController.getPlayer().respawn(this, mGameItemsHolder);
  49         } else {
  50             mForeMap = foreMap;
  51             mBackMap = backMap;
  52             mWidth = mForeMap.length;
  53             mHeight = mForeMap[0].length;
  54         }
  55     }
  56
  57     public int getWidth() {
  58         return mWidth;
  59     }
  60
  61     public int getHeight() {
  62         return mHeight;
  63     }
  64
  65     /**
  66      * @deprecated for kotlin use {@link MeasureUnitsUtilsKt#getPx } extension val
  67      */
  68     @Deprecated
  69     public float getWidthPx() {
  70         return MeasureUnitsUtilsKt.getPx(mWidth);
  71     }
  72
  73     /**
  74      * @deprecated for kotlin use {@link MeasureUnitsUtilsKt#getPx } extension val
  75      */
  76     @Deprecated
  77     public float getHeightPx() {
  78         return MeasureUnitsUtilsKt.getPx(mHeight);
  79     }
  80
  81     public Block[][] getFullForeMap() {
  82         return mForeMap;
  83     }
  84
  85     public Block[][] getFullBackMap() {
  86         return mBackMap;
  87     }
  88
  89     private int transformX(int x) {
  90         x = x % getWidth();
  91         if (x < 0) {
  92             x = getWidth() - Math.abs(x);
  93         }
  94         return x;
  95     }
  96
  97     private Block getMap(int x, int y, int layer) {
  98         Block map = mGameItemsHolder.getFallbackBlock();
  99         try {
 100             x = transformX(x);
 101             map = (layer == 0) ? mForeMap[x][y] : mBackMap[x][y];
 102         } catch (ArrayIndexOutOfBoundsException ignored) {
 103         }
 104         return map;
 105     }
 106
 107     private void setMap(int x, int y, int layer, Block value) {
 108         try {
 109             x = transformX(x);
 110             if (layer == 0) {
 111                 mForeMap[x][y] = value;
 112             } else {
 113                 mBackMap[x][y] = value;
 114             }
 115         } catch (ArrayIndexOutOfBoundsException ignored) {
 116         }
 117     }
 118
 119     private boolean isSameSlab(Block slab1, Block slab2) {
 120         if (!(slab1 instanceof Block.Slab) || !(slab2 instanceof Block.Slab)) {
 121             return false;
 122         }
 123
 124         return slab1.getParams().getKey().equals(((Block.Slab) slab2).getOtherPartBlockKey())
 125                 || slab1.getParams().getKey().equals(slab2.getParams().getKey());
 126     }
 127
 128     public boolean hasForeAt(int x, int y) {
 129         return getMap(x, y, 0) != mGameItemsHolder.getFallbackBlock();
 130     }
 131
 132     public boolean hasBackAt(int x, int y) {
 133         return getMap(x, y, 1) != mGameItemsHolder.getFallbackBlock();
 134     }
 135
 136     public Block getForeMap(int x, int y) {
 137         return getMap(x, y, 0);
 138     }
 139
 140     public void setForeMap(int x, int y, Block block) {
 141         setMap(x, y, 0, block);
 142     }
 143
 144     public void resetForeMap(int x, int y) {
 145         setForeMap(x, y, mGameItemsHolder.getFallbackBlock());
 146     }
 147
 148     public Block getBackMap(int x, int y) {
 149         return getMap(x, y, 1);
 150     }
 151
 152     public void setBackMap(int x, int y, Block block) {
 153         setMap(x, y, 1, block);
 154     }
 155
 156     public boolean placeToForeground(int x, int y, Block value) {
 157         if (!hasForeAt(x, y) || value == mGameItemsHolder.getFallbackBlock() || !getForeMap(x, y).hasCollision()) {
 158             setForeMap(x, y, value);
 159             return true;
 160         } else if (value instanceof Block.Slab && isSameSlab(value, getForeMap(x, y))) {
 161             setForeMap(x, y, mGameItemsHolder.getBlock(((Block.Slab) value).getFullBlockKey()));
 162             return true;
 163         }
 164         return false;
 165     }
 166
 167     public boolean placeToBackground(int x, int y, Block value) {
 168         if (value == mGameItemsHolder.getFallbackBlock() || (getBackMap(x, y) == mGameItemsHolder.getFallbackBlock() && value.hasCollision()) &&
 169                 (!value.isTransparent() || value == mGameItemsHolder.getBlock("glass"))) {
 170             setBackMap(x, y, value);
 171             return true;
 172         }
 173         return false;
 174     }
 175
 176     private void playerDurateTool() {
 177         final InventoryItem playerCurrentItem = mMobsController.getPlayer().getCurrentItem();
 178         if (mMobsController.getPlayer().getCurrentItem().getItem().isTool()) {
 179             mMobsController.getPlayer().decreaseCurrentItemCount(mGameItemsHolder);
 180         }
 181     }
 182
 183     private boolean shouldDrop(Block block) {
 184         final Item item = mMobsController.getPlayer().getCurrentItem().getItem();
 185         int toolLevel = item.isTool() ? ((Item.Tool)item).getLevel() : 0;
 186         if (item.isTool() && block.getParams().getToolType() != item.getClass()) {
 187             toolLevel = 0;
 188         }
 189         return toolLevel >= block.getParams().getToolLevel();
 190     }
 191
 192     public void destroyForeMap(int x, int y) {
 193         Block block = getForeMap(x, y);
 194         if (block.hasDrop() && shouldDrop(block)) {
 195             for (int i = 0; i < block.getParams().getDropInfo().getCount(); i++) {
 196                 mDropController.addDrop(transformX(x) * 16 + 4, y * 16 + 4, mGameItemsHolder.getItem(block.getDrop()));
 197             }
 198         }
 199         playerDurateTool();
 200         placeToForeground(x, y, mGameItemsHolder.getFallbackBlock());
 201     }
 202
 203
 204
 205     public void destroyBackMap(int x, int y) {
 206         Block block = getBackMap(x, y);
 207         if (block.hasDrop() && shouldDrop(block)) {
 208             for (int i = 0; i < block.getParams().getDropInfo().getCount(); i++) {
 209                 mDropController.addDrop(transformX(x) * 16 + 4, y * 16 + 4, mGameItemsHolder.getItem(block.getDrop()));
 210             }
 211         }
 212         playerDurateTool();
 213         placeToBackground(x, y, mGameItemsHolder.getFallbackBlock());
 214     }
 215 }