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