core/src/ru/deadsoftware/cavedroid/game/GameSaver.java

   1 package ru.deadsoftware.cavedroid.game;
   2
   3 import com.badlogic.gdx.Gdx;
   4 import com.badlogic.gdx.files.FileHandle;
   5 import ru.deadsoftware.cavedroid.MainConfig;
   6 import ru.deadsoftware.cavedroid.game.mobs.MobsController;
   7 import ru.deadsoftware.cavedroid.game.model.block.Block;
   8 import ru.deadsoftware.cavedroid.game.objects.drop.DropController;
   9 import ru.deadsoftware.cavedroid.game.objects.container.ContainerController;
  10 import ru.deadsoftware.cavedroid.game.world.GameWorld;
  11
  12 import javax.annotation.CheckForNull;
  13 import java.io.*;
  14 import java.nio.ByteBuffer;
  15 import java.util.HashMap;
  16 import java.util.Map;
  17
  18 public class GameSaver {
  19
  20     private static final String TAG = "GameSaver";
  21
  22     public static class Data {
  23         @CheckForNull
  24         private MobsController mMobsController;
  25         @CheckForNull
  26         private DropController mDropController;
  27         @CheckForNull
  28         private ContainerController mContainerController;
  29         @CheckForNull
  30         private Block[][] mForeMap, mBackMap;
  31
  32         public Data(MobsController mobsController,
  33                     DropController dropController,
  34                     ContainerController containerController,
  35                     Block[][] foreMap,
  36                     Block[][] backMap) {
  37             mMobsController = mobsController;
  38             mDropController = dropController;
  39             mContainerController = containerController;
  40             mForeMap = foreMap;
  41             mBackMap = backMap;
  42         }
  43
  44         public MobsController retrieveMobsController() {
  45             assert mMobsController != null;
  46             MobsController mobsController = mMobsController;
  47             mMobsController = null;
  48             return mobsController;
  49         }
  50
  51         public DropController retrieveDropController() {
  52             assert mDropController != null;
  53             DropController dropController = mDropController;
  54             mDropController = null;
  55             return dropController;
  56         }
  57
  58         public ContainerController retrieveFurnaceController() {
  59             assert mContainerController != null;
  60             ContainerController containerController = mContainerController;
  61             mContainerController = null;
  62             return containerController;
  63         }
  64
  65         public Block[][] retrieveForeMap() {
  66             assert mForeMap != null;
  67             Block[][] foreMap = mForeMap;
  68             mForeMap = null;
  69             return foreMap;
  70         }
  71
  72         public Block[][] retrieveBackMap() {
  73             assert mBackMap != null;
  74             Block[][] backMap = mBackMap;
  75             mBackMap = null;
  76             return backMap;
  77         }
  78
  79         public boolean isEmpty() {
  80             return mMobsController == null &&
  81                     mDropController == null &&
  82                     mContainerController == null &&
  83                     mForeMap == null &&
  84                     mBackMap == null;
  85         }
  86     }
  87
  88     private static final int SAVE_VERSION = 1;
  89
  90     private static byte[] intToBytes(int i) {
  91         return ByteBuffer.allocate(4).putInt(i).array();
  92     }
  93
  94     private static Map<String, Integer> buildBlocksDictionary(Block[][] foreMap, Block[][] backMap) {
  95         final HashMap<String, Integer> dict = new HashMap<>();
  96
  97         int id = 0;
  98         for (int i = 0; i < foreMap.length; i++) {
  99             for (int j = 0; j < foreMap[i].length; j++) {
 100                 for (int k = 0; k < 2; k++) {
 101                     final Block block = k == 0 ? foreMap[i][j] : backMap[i][j];
 102                     final String key = block.getParams().getKey();
 103                     if (!dict.containsKey(key)) {
 104                         dict.put(key, id++);
 105                     }
 106                 }
 107             }
 108         }
 109
 110         return dict;
 111     }
 112
 113     private static void saveDict(FileHandle file, Map<String, Integer> dict) {
 114         final String[] arr = new String[dict.size()];
 115
 116         for (Map.Entry<String, Integer> entry : dict.entrySet()) {
 117             arr[entry.getValue()] = entry.getKey();
 118         }
 119
 120         final StringBuilder builder = new StringBuilder();
 121         for (String key : arr) {
 122             builder.append(key);
 123             builder.append('\n');
 124         }
 125
 126         file.writeString(builder.toString(), false);
 127     }
 128
 129     private static String[] loadDict(FileHandle file) {
 130         return file.readString().split("\n");
 131     }
 132
 133     private static void saveMap(FileHandle file, Block[][] map, Map<String, Integer> dict) throws IOException {
 134         int run, block;
 135         int width = map.length;
 136         int height = map[0].length;
 137
 138         BufferedOutputStream out = new BufferedOutputStream(file.write(false));
 139
 140         out.write(SAVE_VERSION);
 141         out.write(intToBytes(width));
 142         out.write(intToBytes(height));
 143
 144         for (int y = 0; y < height; y++) {
 145             block = dict.get(map[0][y].getParams().getKey());
 146             run = 0;
 147             for (Block[] blocks : map) {
 148                 int newValue = dict.get(blocks[y].getParams().getKey());
 149                 if (run >= 0xFF || newValue != block) {
 150                     out.write(run);
 151                     out.write(block);
 152                     run = 0;
 153                     block = dict.get(blocks[y].getParams().getKey());
 154                 }
 155                 run++;
 156             }
 157             out.write(run);
 158             out.write(block);
 159         }
 160
 161         out.flush();
 162         out.close();
 163     }
 164
 165     private static Block[][] loadMap(GameItemsHolder gameItemsHolder, FileHandle file, String[] dict) throws Exception {
 166         Block[][] map;
 167         int version, width, height;
 168         int run, block;
 169
 170         DataInputStream in = new DataInputStream(file.read());
 171
 172         version = in.readByte();
 173
 174         if (SAVE_VERSION == version) {
 175             width = in.readInt();
 176             height = in.readInt();
 177             map = new Block[width][height];
 178             for (int y = 0; y < height; y++) {
 179                 for (int x = 0; x < width; x += run) {
 180                     run = in.readUnsignedByte();
 181                     block = in.readUnsignedByte();
 182                     for (int i = x; i < x + run; i++) {
 183                         map[i][y] = gameItemsHolder.getBlock(dict[block]);
 184                     }
 185                 }
 186             }
 187         } else {
 188             throw new Exception("version mismatch");
 189         }
 190
 191         in.close();
 192         return map;
 193     }
 194
 195     @CheckForNull
 196     public static Data load(MainConfig mainConfig, GameItemsHolder gameItemsHolder) {
 197         String folder = mainConfig.getGameFolder();
 198         FileHandle file = Gdx.files.absolute(folder + "/saves/game.sav");
 199
 200         try {
 201             ObjectInputStream in = new ObjectInputStream(file.read());
 202             int version = in.readInt();
 203             DropController dropController;
 204             MobsController mobsController;
 205             ContainerController containerController;
 206
 207             if (SAVE_VERSION == version) {
 208                 dropController = (DropController) in.readObject();
 209                 mobsController = (MobsController) in.readObject();
 210                 containerController = (ContainerController) in.readObject();
 211             } else {
 212                 throw new Exception("version mismatch");
 213             }
 214
 215             in.close();
 216
 217             final String[] dict = loadDict(Gdx.files.absolute(mainConfig.getGameFolder() + "/saves/dict"));
 218             Block[][] foreMap = loadMap(gameItemsHolder, Gdx.files.absolute(mainConfig.getGameFolder() + "/saves/foremap.sav"), dict);
 219             Block[][] backMap = loadMap(gameItemsHolder, Gdx.files.absolute(mainConfig.getGameFolder() + "/saves/backmap.sav"), dict);
 220
 221             if (dropController == null || mobsController == null) {
 222                 throw new Exception("couldn't load");
 223             }
 224
 225             return new Data(mobsController, dropController, containerController, foreMap, backMap);
 226         } catch (Exception e) {
 227             Gdx.app.error("GameSaver", e.getMessage());
 228         }
 229
 230         return null;
 231     }
 232
 233     public static void save(MainConfig mainConfig,
 234                             DropController dropController,
 235                             MobsController mobsController,
 236                             ContainerController containerController,
 237                             GameWorld gameWorld) {
 238         String folder = mainConfig.getGameFolder();
 239         FileHandle file = Gdx.files.absolute(folder + "/saves/");
 240         file.mkdirs();
 241         file = Gdx.files.absolute(folder + "/saves/game.sav");
 242
 243         final Block[][] foreMap, backMap;
 244         foreMap = gameWorld.getFullForeMap();
 245         backMap = gameWorld.getFullBackMap();
 246
 247         final Map<String, Integer> dict = buildBlocksDictionary(foreMap, backMap);
 248
 249         try {
 250             ObjectOutputStream out = new ObjectOutputStream(file.write(false));
 251             out.writeInt(SAVE_VERSION);
 252             out.writeObject(dropController);
 253             out.writeObject(mobsController);
 254             out.writeObject(containerController);
 255             out.close();
 256
 257             saveDict(Gdx.files.absolute(folder + "/saves/dict"), dict);
 258             saveMap(Gdx.files.absolute(folder + "/saves/foremap.sav"), gameWorld.getFullForeMap(), dict);
 259             saveMap(Gdx.files.absolute(folder + "/saves/backmap.sav"), gameWorld.getFullBackMap(), dict);
 260         } catch (Exception e) {
 261             e.printStackTrace();
 262         }
 263     }
 264
 265     public static boolean exists(MainConfig mainConfig) {
 266         String folder = mainConfig.getGameFolder();
 267         return (Gdx.files.absolute(folder + "/saves/game.sav").exists() &&
 268                 Gdx.files.absolute(folder + "/saves/foremap.sav").exists() &&
 269                 Gdx.files.absolute(folder + "/saves/backmap.sav").exists());
 270     }
 271 }