Как написать игру под Android за 15 дней. История создания Mega Flood-It. Часть первая

от
GameDev   gamedev, android, flood-it, рекурсия, история разработки

Ещё в далёком декабре 2016-го я начал писать игру под Android и параллельно описывал ход разработки, чтобы в один прекрасный момент (сегодня) восстановить события и поведать о том, как пришла идея игры, с чего я начал разработку, какие трудности возникли и что приходилось делать, чтобы облегчить себе работу.

mfi_logo1.png

День 0
15 декабря 2016 года. После обеда захотелось немного полежать и скоротать время за игрой на телефоне. Динамические игры я не очень люблю, хотелось чего-то простого, ведь мой любимый жанр игр — головоломки и логические игры. И тут я вспомнил про старую добрую Flood-It. То, что нужно!
Первая игра в выдаче маркета была неплохой, но интерфейс был не очень приятным, попросту уставали глаза. Стали интересны другие реализации. Вторая игра была с обилием рекламы и ничего хорошего из себя не представляла. В третьей с графикой было всё нормально, но после каждого проигрыша прогресс начисто сбивался и нужно было проходить одни и те же уровни заново. Игры на движках типа Unity я даже не устанавливал, во-первых, писать логическую игру на таком движке это явно перебор, а во-вторых, на моей Sony Xperia Pro не было памяти для установки таких больших игр.

В общем, игр Flood-It в маркете было много, но той, которую требовала душа, не было. И тогда я решил, что сделаю лучшую игру Flood-It: огромное множество уровней, смена стилей, ночная тема и статистика — вот те самые важные для моей души критерии.


День 1
Разработка началась с запуска Android Studio и создания проекта. Уже тогда пронеслась мысль, а успею ли я реализовать задуманное до нового года? В запасе было ещё две недели, так что я не стал расписывать и продумывать всё до мелочей, а сломя голову принялся писать код, проектируя на ходу. Идея была следующей: как можно быстрее написать рабочий прототип, а дальше уже просто наращивать функционал.

Начать решил с модели, чтобы всё работало просто "в памяти", а потом уже к этой модели прикрутить вид. Создал класс Board — игровая доска:
  1. public class Board {
  2.     private final int[][] board;
  3.     private int maxColors;
  4.  
  5.     public Board generate(BoardGenerator generator) {
  6.         generator.reinit();
  7.         final int size = board.length;
  8.         for (int y = 0; y < size; y++) {
  9.             for (int x = 0; x < size; x++) {
  10.                 board[y][x] = generator.generate(maxColors);
  11.             }
  12.         }
  13.         return this;
  14.     }
  15.  
  16.     public int getCellAt(int x, int y) { /* .. */ }
  17.  
  18.     public Board updateAt(int x, int y, int color) { /* .. */ }
  19.  
  20.     public int fill(int color) {
  21.         int cell = getCellAt(0, 0);
  22.         if (cell != color) {
  23.             return fill(0, 0, cell, color);
  24.         }
  25.         return 0;
  26.     }
  27.  
  28.     private int fill(int x, int y, int prevColor, int color) {
  29.         if ( (x < 0) || (y < 0) || (x >= board.length) || (y >= board.length) ) {
  30.             return 0;
  31.         }
  32.         int filled = 0;
  33.         if (board[x][y] == prevColor) {
  34.             board[x][y] = color;
  35.             filled++;
  36.             filled += fill(x - 1, y, prevColor, color);
  37.             filled += fill(x + 1, y, prevColor, color);
  38.             filled += fill(x, y - 1, prevColor, color);
  39.             filled += fill(x, y + 1, prevColor, color);
  40.         }
  41.         return filled;
  42.     }
  43. }

Здесь можно задать размер доски и количество цветов. Есть метод заливки заданным цветом, который потом и будет вызываться при каждом ходе игрока. Метод возвращает количество залитых клеток не просто так, это нужно было для статистики, которая была одной из ключевых фишек моей игры. Алгоритм заливки пока что рекурсивный, думал, что Android справится. Генерированием игрового поля занимается класс BoardGenerator:
  1. public class BoardGenerator {
  2.  
  3.     private final long seed;
  4.     private Random random;
  5.  
  6.     public BoardGenerator(long seed) {
  7.         this.seed = seed;
  8.         reinit();
  9.     }
  10.  
  11.     public void reinit() {
  12.         random = new Random(seed);
  13.     }
  14.  
  15.     public int generate(int max) {
  16.         return random.nextInt(max);
  17.     }
  18. }

Пока что это просто обёртка над классом Random, но проще оперировать сущностью BoardGenerator, чем Random. Ещё я создал класс Palette, обозначающий палитру, которую затем можно было бы менять в настройках:
  1. public class Palette {
  2.  
  3.     private final int[] colors;
  4.  
  5.     public int getColor(int index) { /* .. */ }
  6. }

Этих классов уже было достаточно, чтобы можно было играть, вызывая методы, так что я принялся за вид. Экран должен делиться на две логические части: игровое поле — квадрат размером NxN и панель с цветными кнопками, которые будет нажимать игрок, делая ход.

Игровое поле я сделал в виде вьюшки на канвасе:
  1. public class BoardView extends View {
  2.  
  3.     private Board board;
  4.     private Palette palette;
  5.  
  6.     @Override
  7.     protected void onDraw(Canvas canvas) {
  8.         if (isInEditMode()) {
  9.             canvas.drawColor(Color.LTGRAY);
  10.             return;
  11.         }
  12.         if (board == null) return;
  13.         if (palette == null) return;
  14.  
  15.         int size = board.getBoardSize();
  16.         int[] colors = palette.getColors();
  17.         int cellSize = Math.min(canvas.getWidth(), canvas.getHeight()) / size;
  18.         for (int y = 0; y < size; y++) {
  19.             for (int x = 0; x < size; x++) {
  20.                 paint.setColor(colors[board.getCellAt(x, y)]);
  21.                 int left = x * cellSize;
  22.                 int top = y * cellSize;
  23.                 canvas.drawRect(left, top, left + cellSize, top + cellSize, paint);
  24.             }
  25.         }
  26.     }
  27. }
Просто отрисовка клеток, цвет которых берётся из класса Palette.
За игровые кнопки у меня отвечал другой класс — ButtonsManager, состоящий из maxColors расположенных последовательно View во ViewGroup:
  1. public class ButtonsManager {
  2.  
  3.     private static final int FIRST_ID = 1000;
  4.     private View[] buttons;
  5.  
  6.     private ButtonsManager(ViewGroup layout) {
  7.         int childCount = layout.getChildCount();
  8.         buttons = new View[childCount];
  9.         for (int i = 0; i < childCount; i++) {
  10.             buttons[i] = layout.getChildAt(i);
  11.             buttons[i].setId(FIRST_ID + i);
  12.         }
  13.     }
  14.  
  15.     public ButtonsManager maxColors(int max) {
  16.         for (int i = 0; i < max; i++) {
  17.             buttons[i].setVisibility(View.VISIBLE);
  18.         }
  19.         for (int i = max; i < buttons.length; i++) {
  20.             buttons[i].setVisibility(View.GONE);
  21.         }
  22.         return this;
  23.     }
  24.  
  25.     public ButtonsManager palette(Palette palette) {
  26.         for (int i = 0; i < buttons.length; i++) {
  27.             buttons[i].setBackgroundColor(palette.getColor(i));
  28.         }
  29.         return this;
  30.     }
  31.  
  32.     public ButtonsManager listener(ColorButtonListener listener) {
  33.         View.OnClickListener clickListener = v -> {
  34.             listener.onClick(v, v.getId() - FIRST_ID);
  35.         };
  36.         for (View button : buttons) {
  37.             button.setOnClickListener(clickListener);
  38.         }
  39.         return this;
  40.     }
  41. }
  42.  
  43. public interface ColorButtonListener {
  44.     void onClick(View v, int index);
  45. }

Теперь кое-как связываем модель и вид:
  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) {
  5.         final int maxColors = 6;
  6.         BoardGenerator generator = new BoardGenerator();
  7.         Palette palette = new Palette(
  8.                 getResources().getIntArray(R.array.standardPalette));
  9.         Board board = Board.create(8).maxColors(maxColors).generate(generator);
  10.         BoardView boardView = (BoardView) findViewById(R.id.board);
  11.         boardView.board(board)
  12.                 .palette(palette);
  13.  
  14.         ButtonsManager.from(findViewById(R.id.buttonsLayout))
  15.                 .maxColors(maxColors)
  16.                 .palette(palette)
  17.                 .listener((view, index) -> {
  18.                         board.fill(index);
  19.                         boardView.invalidate();
  20.                     }
  21.                 });
  22.     }
  23. }
И получаем самый что ни на есть простой, но зато работающий прототип игры за один день. И ничего, что после заливки всего поля, игру нужно перезапускать. :gg:

device-2018-10-03-202548.png

2016-12-16.apk


День 2
Первой проблемой, с которой я столкнулся был вылет игры в некоторых ситуациях. Небольшое подвисание, а затем большой стектрейс с повторяющимися строками говорил о том, что где-то переполнение стека. Такое место у меня было пока что одно — рекурсия в методе заливки.
И, верно, проблема была. Заливка не учитывала уже залитые клетки и могла на последующих итерациях заливать их снова и снова. Решается дополнительным массивом boolean[][], где отмечаются залитые клетки:
  1. public int fill(int color) {
  2.     int cell = getCellAt(0, 0);
  3.     if (cell != color) {
  4.         int size = board.length;
  5.         boolean[][] visited = new boolean[size][size];
  6.         return fill(0, 0, cell, color, visited);
  7.     }
  8.     return 0;
  9. }
  10.  
  11. private int fill(int x, int y, int prevColor, int color, boolean[][] visited) {
  12.     if ( (x < 0) || (y < 0) || (x >= board.length) || (y >= board.length)
  13.             || visited[y][x]) {
  14.         return 0;
  15.     }
  16.     int filled = 0;
  17.     if (board[y][x] == prevColor) {
  18.         board[y][x] = color;
  19.         visited[y][x] = true;
  20.         filled++;
  21.         filled += fill(x - 1, y, prevColor, color, visited);
  22.         filled += fill(x + 1, y, prevColor, color, visited);
  23.         filled += fill(x, y - 1, prevColor, color, visited);
  24.         filled += fill(x, y + 1, prevColor, color, visited);
  25.     }
  26.     return filled;
  27. }

Игре не хватало проверки выигрышной ситуации, когда всё поле залито одним цветом. Поэтому добавился метод Board.isCompleted():
  1. public boolean isCompleted() {
  2.     final int size = board.length;
  3.     final int color = board[0][0];
  4.     for (int y = size - 1; y >= 0; y--) {
  5.         for (int x = 0; x < size; x++) {
  6.             if (board[y][x] != color) return false;
  7.         }
  8.     }
  9.     return true;
  10. }
По правилам игры заливать поле игрок начинает с верхнего левого угла, то есть намного чаще будут залиты одним цветом верхние ряды, чем нижние. Значит, быстрее проверять поле не сверху вниз, а снизу вверх.

После этого я приступил ко второй ключевой особенности игры — ночной теме. В палитре теперь хранились цвета для дневной и для ночной темы, чтобы можно было быстро между ними переключаться, не загружая палитру заново:
  1. public class Palette {
  2.     private final int[] dayColors;
  3.     private final int[] nightColors;
  4.  
  5.     public int getColor(int index) {
  6.         if (isNight) return getNightColor(index);
  7.         else return getDayColor(index);
  8.     }
  9.  
  10.     public int getDayColor(int index) {
  11.         if (index < 0 || index >= dayColors.length) {
  12.             return -1;
  13.         }
  14.         return dayColors[index];
  15.     }
  16.  
  17.     public int getNightColor(int index) {
  18.         if (index < 0 || index >= nightColors.length) {
  19.             return -1;
  20.         }
  21.         return nightColors[index];
  22.     }
  23. }

При этом сама тема приложения пока что не меняется, просто задаётся светлый или тёмный фон при переключении.
Также поработал над кнопками управления, сделав их квадратными.

device-2018-10-04-011845.png
2016-12-17.apk


День 3
Наконец-то дошли руки переписать рекурсивный алгоритм заливки на нерекурсивный с использованием Deque:
  1. public int fill(int color) {
  2.     final int prevColor = getCellAt(0, 0);
  3.     if (prevColor != color) {
  4.         final int size = board.length;
  5.         boolean[][] visited = new boolean[size][size];
  6.         Deque<Point> deque = new ArrayDeque<>(size * 2);
  7.         deque.add(new Point(0, 0));
  8.         int filled = 0;
  9.         while (!deque.isEmpty()) {
  10.             Point p = deque.remove();
  11.             int x = p.x;
  12.             int y = p.y;
  13.  
  14.             visited[y][x] = true;
  15.             if (board[y][x] != prevColor) {
  16.                 continue;
  17.             }
  18.  
  19.             board[y][x] = color;
  20.             filled++;
  21.  
  22.             for (int i = -1; i <= 1; i += 2) {
  23.                 final int newX = x + i;
  24.                 if ( (0 <= newX) && (newX < size) && !visited[y][newX]) {
  25.                     deque.add(new Point(newX, y));
  26.                 }
  27.                 final int newY = y + i;
  28.                 if ( (0 <= newY) && (newY < size) && !visited[newY][x]) {
  29.                     deque.add(new Point(x, newY));
  30.                 }
  31.             }
  32.         }
  33.         return filled;
  34.     }
  35.     return 0;
  36. }

Теперь уж точно нигде переполнение стека не произойдёт. Также добавил экран меню, в котором работает только первый пункт:
device-2018-10-04-121600.png


День 4
Добавил экран выбора режима игры c отображением размерности поля, количества цветов и картинки-превью. Размерность: 8x8, 12x12, 16x16, 20x20 и 24x24. Для каждой размерности поля есть три режима: 4 цвета, 6 цветов и 8 цветов. Итого 15 режимов.
  1. @Override
  2. protected void onCreate(Bundle savedInstanceState) {
  3.     setContentView(R.layout.mode_selector);
  4.     final Random rnd = new Random();
  5.     palette = new Palette(
  6.             getResources().getIntArray(R.array.standardPalette),
  7.             getResources().getIntArray(R.array.standardPalette_dark));
  8.  
  9.     adapter = new ModeAdapter(this);
  10.     for (int boardSize = 8; boardSize <= 24; boardSize += 4) {
  11.         for (int maxColors = 4; maxColors <= 8; maxColors += 2) {
  12.             GameMode mode = new GameMode(boardSize, maxColors);
  13.             mode.setLevelsCount(100);
  14.             mode.setLevel(rnd.nextInt(100));
  15.             mode.setPreview(generatePreview(boardSize, maxColors));
  16.             adapter.add(mode);
  17.         }
  18.     }
  19.     listView.setAdapter(adapter);
  20.     listView.setOnItemClickListener(this);
  21. }
  22.  
  23. @Override
  24. public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
  25.     GameMode mode = adapter.getItem(position);
  26.     startActivity(GameActivity.newIntent(this, mode.getBoardSize(), mode.getMaxColors()));
  27. }
  28.  
  29. private Bitmap generatePreview(int boardSize, int maxColors) {
  30.     float density = getResources().getDisplayMetrics().density;
  31.     int size = (int) (100 * density);
  32.     Bitmap bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
  33.     Canvas canvas = new Canvas(bitmap);
  34.  
  35.     Random random = new Random(boardSize * 100 + maxColors);
  36.     Paint paint = new Paint();
  37.     int cellSize = size / boardSize;
  38.     int yStart = (size - boardSize * cellSize) / 2;
  39.     for (int y = 0; y < boardSize; y++) {
  40.         for (int x = 0; x < boardSize; x++) {
  41.             int color = palette.getColor(random.nextInt(maxColors));
  42.             paint.setColor(color);
  43.             int left = x * cellSize;
  44.             int top = y * cellSize + yStart;
  45.             canvas.drawRect(left, top, left + cellSize, top + cellSize, paint);
  46.         }
  47.     }
  48.     return bitmap;
  49. }

По крайней мере, уже можно выбрать тот режим, который хочется поиграть.
device-2018-10-04-123215.png

2016-12-19.apk


День 5
Новый день — новый экран. На этот раз добавил выбор уровня в указанном режиме. У уровня есть такие параметры:
  1. public class Level {
  2.     public static int MAX_LEVELS = 100;
  3.  
  4.     private final int number;
  5.     private int maxMoves, playerMoves;
  6.     private int backgroundResource;
  7.     private boolean isAvailable;
  8. }
Номер уровня, их будет 100 в каждом из 15 режимов.
Максимально допустимое число ходов для уровня. Если игрок превышает это число, то уровень считается не пройденным. Также хранится лучший результат игрока для этого уровня.
Ресурс фона — метка уровня. Если уровень пройден или открыт, то фон отображается зелёным, если не пройден — красным, а если пока недоступен — серым.
Наконец, хранится доступность уровня. Игроку не сразу доступны все уровни, они открываются по мере прохождения игры.

Также сделал сохранение прогресса игры. Просто в файл пишем количество ходов игрока для всех уровней, которые были сыграны.
  1. private static void writeLevelsCompletion(Context context, String filename,
  2.         List<Level> levels) throws IOException {
  3.     DataOutputStream dos = new DataOutputStream(
  4.             context.openFileOutput(filename, Context.MODE_PRIVATE)
  5.     );
  6.     int openedLevels = levels.size();
  7.     dos.writeInt(openedLevels);
  8.     for (int i = 0; i < openedLevels; i++) {
  9.         Level level = levels.get(i);
  10.         dos.writeInt(level.getPlayerMoves());
  11.     }
  12.     dos.flush();
  13.     dos.close();
  14. }
  15.  
  16. private static List<Level> readLevelsCompletion(Context context, String filename)
  17.         throws IOException {
  18.     if (context.getFileStreamPath(filename).exists()) {
  19.         DataInputStream dis = new DataInputStream(context.openFileInput(filename));
  20.         int openedLevels = dis.readInt();
  21.         List<Level> levels = new ArrayList<>(openedLevels);
  22.         for (int i = 1; i <= openedLevels; i++) {
  23.             Level level = new Level(i);
  24.             level.setAvailable(true);
  25.             level.setPlayerMoves(dis.readInt());
  26.             levels.add(level);
  27.         }
  28.         dis.close();
  29.         return levels;
  30.     }
  31.     return new ArrayList<>();
  32. }

Теперь в игре было 1500 уровней. На самом деле, их можно сделать гораздо больше и вот почему. В первый день я создавал класс BoardGenerator, который являлся простой обёрткой над Random и принимал seed:
  1. public BoardGenerator(long seed) {
  2.     this.seed = seed;
  3.     reinit();
  4. }

Если для этого генератора задать seed = 1, то всегда будет генерироваться один и тот же уровень. Если 2, то уже другой. И так далее. А чисел в long ведь гораздо больше 1500! Вот и получается, что в любой момент игру можно расширить до такого количества уровней, что никто и играть не захочет (на самом деле при 1500 я предполагал, что тоже будет такой эффект).

В игре теперь поле генерировалось так:
  1. private void newBoard() {
  2.     generator = new BoardGenerator(getSeed());
  3.     board = Board.create(boardSize)
  4.             .maxColors(maxColors)
  5.             .generate(generator);
  6.     boardView.board(board)
  7.             .palette(palette);
  8.     buttonsManager = ButtonsManager.from(buttonsLayout)
  9.             .maxColors(maxColors)
  10.             .palette(palette)
  11.             .listener(this);
  12. }
  13.  
  14. private long getSeed() {
  15.     return seed == RANDOM_SEED ? System.currentTimeMillis() : seed;
  16. }

Если выбирался именно уровень, а не просто режим случайной игры, то seed равнялся номеру уровня.

device-2018-10-04-152547.png device-2018-10-04-152607.png device-2018-10-04-152640.png

2016-12-20.apk

  1. private void updateLevels() {
  2.     adapter.clear();
  3.     List<Level> openedLevels = Prefs.readLevelsCompletion(this, boardSize, maxColors);
  4.     int openedLevelsCount = openedLevels.size();
  5.     for (int i = 1; i <= Level.MAX_LEVELS; i++) {
  6.         Level level = new Level(i);
  7.         level.setMaxMoves(25);
  8.         if (i - 1 < openedLevelsCount) {
  9.             Level openedLevel = openedLevels.get(i - 1);
  10.             level.setAvailable(true);
  11.             level.setPlayerMoves(openedLevel.getPlayerMoves());
  12.         } else {
  13.             // Next after last opened level available always
  14.             level.setAvailable((i - 1 == openedLevelsCount));
  15.             level.setPlayerMoves(0);
  16.         }
  17.         if (level.isAvailable()) {
  18.             level.setBackgroundResource(level.getPlayerMoves() > level.getMaxMoves()
  19.                     ? R.drawable.level_item_lost
  20.                     : R.drawable.level_item_normal);
  21.         } else {
  22.             level.setBackgroundResource(R.drawable.level_item_disabled);
  23.         }
  24.         adapter.add(level);
  25.     }
  26.     adapter.notifyDataSetChanged();
  27. }

Пока что оставался один нерешённый момент, а именно level.setMaxMoves(25). Эта строчка как будто насмехалась: Любишь уровни на основе рандома генерировать, люби и оптимальное число ходов высчитывать. И тогда я закрыл Android Studio и открыл NetBeans, чтобы написать на Java SE небольшой класс, но тут время перевалило за полночь, а это уже:


День 6
Когда-то я писал на Хабре статью про создание бота для игры Flood-It, который находил поле и сам нажимал на нужные кнопки. На основе этого кода я сделал solver:
  1. public class FloodItSolver {
  2.  
  3.     private void process() {
  4.         int minBoardSize = 8, maxBoardSize = 24, stepBoardSize = 4;
  5.         int minColors = 4, maxColors = 8, stepColors = 2;
  6.         int size = ((maxBoardSize - minBoardSize) / stepBoardSize);
  7.         Map<String, int[]> levelsCount = new LinkedHashMap<>(size + 2);
  8.         for (int boardSize = minBoardSize; boardSize <= maxBoardSize; boardSize += stepBoardSize) {
  9.             for (int colors = minColors; colors <= maxColors; colors += stepColors) {
  10.                 GameMode mode = new GameMode(boardSize, colors);
  11.                 int[] minMoves = processMode(mode);
  12.                 levelsCount.put(mode.toString(), minMoves);
  13.                 saveLevelsCount(mode, minMoves);
  14.             }
  15.         }
  16.     }
  17.  
  18.     private void saveLevelsCount(GameMode mode, int[] minMoves) {
  19.         File file = new File(mode.toString());
  20.         try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(file))) {
  21.             dos.writeByte(0);
  22.             for (int moves : minMoves) {
  23.                 dos.writeByte(moves);
  24.             }
  25.             dos.flush();
  26.         } catch (IOException ex) {
  27.         }
  28.     }
  29.  
  30.     private int[] processMode(GameMode mode) {
  31.         int[] minMoves = new int[MAX_LEVELS];
  32.         for (int level = 1; level <= 100; level++) {
  33.             int moves = processMovesCalculation(mode, level);
  34.             minMoves[level - 1] = moves;
  35.             System.out.format("Level: %d, moves: %d%n", level, moves);
  36.         }
  37.         return minMoves;
  38.     }
  39.  
  40.     private int stepsForLevel(int level) {
  41.         int percent = ((level - 1) * 100 / MAX_LEVELS);
  42.         int steps = stepsForPercent(percent);
  43.         if (level % 10 == 0) {
  44.             return steps + 1;
  45.         }
  46.         return steps;
  47.     }
  48.  
  49.     private int stepsForPercent(int percent) {
  50.         if (percent < 20) return 1;
  51.         if (percent < 60) return 2;
  52.         if (percent < 90) return 3;
  53.         return 4;
  54.     }
  55. }

Класс Random при передаче одинаковых сидов выдаёт одни и те же последовательности как в Android, так и в Java SE. Это значит, что можно генерировать одинаковые уровни на обеих платформах и расчёт оптимального количества ходов можно сделать на ПК. Этим я и занимался всё утро.

Количество ходов на уровень сохраняется в файле. Нулевой байт не трогаем, в первом хранится число ходов для первого уровня, во втором для второго и так далее. Получаем 15 файлов по 100 байт каждый.

У алгоритма расчёта есть параметр — глубина просмотра ходов. Чем выше значение, тем оптимальнее просчитываются ходы. Для первых 20 уровней я взял минимальную глубину, чтобы число ходов было с запасом. Дальше, до 60-го уровня глубина была уже выше. До 90 ещё выше и последние 10 уровней были вообще для мегамозгов (на самом деле нет, но об этом позже). Дополнительно, каждый десятый уровень был с повышенной на одно значение сложностью. Это всё видно в последних двух методах stepsForLevel и stepsForPercent.

На деле же оказалось, что высокая глубина просчёта иногда давала не совсем оптимальный результат по сравнению с меньшей глубиной. Но об этом я узнал намного позже, когда все файлы уже были сгенерированы, а перегенерировать не хотелось. В итоге этот промах стал "приятной фичей для тех, кто прошел 90 уровней".

Во второй половине дня немного изменил стиль выбора режима и уровня.

device-2018-10-04-180438.png device-2018-10-04-180456.png

2016-12-21.apk


День 7
И был день, и была но… Ой, ночи у нас пока не было. Самое время это исправить. Когда стили для ночной темы были готовы и кнопка переключения наконец-то переключала тему, а не меняла фон, я столкнулся с небольшой проблемой. Если в игре сменить тему, а потом вернуться назад, то предыдущая активити всё ещё будет с изначальной темой. Поэтому при переходе между активити нужно проверять, совпадает ли тема в настройках с текущей темой в активити.
  1. public abstract class ThemeableActivity extends AppCompatActivity {
  2.  
  3.     protected int themeId;
  4.  
  5.     @Override
  6.     protected void onCreate(Bundle savedInstanceState) {
  7.         themeId = Prefs.with(this).getThemeId();
  8.         setTheme(themeId);
  9.         super.onCreate(savedInstanceState);
  10.     }
  11.  
  12.     @Override
  13.     protected void onResume() {
  14.         super.onResume();
  15.         if (Prefs.with(this).getThemeId() != ResourceUtils.resolveResourceId(this, R.attr.themeId)) {
  16.             recreate();
  17.         }
  18.     }
  19.  
  20.     protected boolean isNightTheme() {
  21.         return themeId == R.style.AppTheme_Night;
  22.     }
  23.  
  24.     protected void toggleTheme() {
  25.         final Prefs prefs = Prefs.with(this);
  26.         final int newThemeId;
  27.         switch (prefs.getThemeId()) {
  28.             case R.style.AppTheme:
  29.                 newThemeId = R.style.AppTheme_Night;
  30.                 break;
  31.             case R.style.AppTheme_Night:
  32.             default:
  33.                 newThemeId = R.style.AppTheme;
  34.                 break;
  35.         }
  36.         prefs.setThemeId(newThemeId);
  37.         recreate();
  38.     }
  39. }

Теперь, наследуясь от класса ThemeableActivity, мы получаем автоматическую поддержку тем.

Также сделал учёт статистики: количество нажатий, число игр, выигрышей и рестартов, число залитых клеток.
  1. Statistics.with(this)
  2.         .updateClicksFor(index)
  3.         .updateFilledCount(filled);
  4. // ..
  5. if (board.isCompleted()) {
  6.     Statistics.with(this)
  7.             .updateGamesPlayedCount()
  8.             .updateWinsCount();
  9.     // ..
  10. }

device-2018-10-04-185807.png

2016-12-22.apk


Так прошла неделя. Теперь, имея на руках работающую игру, оставалось только добавлять функционал и придумывать новые идеи.

В следующей части: как подобрать цвета для клеток и не сойти с ума, конечная заставка, история ходов и многое другое.
+10   10   0
371

  © aNNiMON (Melnik Software)
Онлайн: 46 (0/46)
 
Яндекс.Метрика