Огромный бюджет и сверхсовременная графика далеко не всегда являются залогом успешности игры. Напротив, существует немало популярных проектов, созданных в краткие сроки и при отсутствии серьезной финансовой базы. Примером такового может служить приложение-игра 2048, появившееся в 2014 году. Как пройти 2048 следуя простым и ясным правилам далее в статье.

История игры 2048 довольно занятна — молодой итальянский программист на имя Габриэле Чирулли решил отвлечь себя от бытовой работы. Упражняясь с языком JavaScript, он потратил два дня на то, что бы создать простое и интересное развлечение.

В качестве основы его детища были использованы принципы популярной игры «Threes». Результат произошел сам себя. Прохождение приложения 2048 получило огромную популярность всего лишь за несколько недель, а вопросом «Как пройти 2048?» стали задаваться не только юные игроки, но и те кто только начал своё знакомство с данной головоломкой. Более того — известность проекта достигла уровня своего «прародителя», а возможно и превысила его.

Геймплей

Игровое поле состоит из квадрата 4х4. Каждый ход на одной из его клеток возникает новый куб с числом «2» или «4». Геймер может воздействовать с ними, направляя все фигуры в одном из направлений (вверх, вниз, влево или вправо).

Играть 2048 онлайн:

В случае если две равноценных фигуры сталкиваются друг с другом («2» и «2», «4» и «4», и т.д.) образовывается новый куб с удвоенным числом («4», «8», «16» и т.д.). Цель игры — создать фигуру с числом «2048». Так же, данное приложение 2048 предусматривает возможность проигрыша. Он наступает в той ситуации, когда игрок не может сделать новый ход (при полном заполнении игрового поля).

Как проходить 2048

Несмотря на свою кажущуюся простоту прохождения, игра не только затягивает, но и заставляет «напрячь извилины». Как пройти 2048 следуя инструкциям далее согласно секретам.

Существует несколько секретов, которые могут в значительной мере упростить прохождение игры 2048.

• Во-первых — забудьте про движение вверх. Фигуры нужно сталкивать только вниз, вправо или влево. Направлять их ввысь стоит лишь в том случае, если игрок стоит на гране поражения и другие варианты попросту отсутствуют;
• Во-вторых — сконцентрируйтесь на нижнем ряду поля. Оно должно быть постоянно заполнено. С помощью этого геймер сможет убить сразу двух зайцев:
• 1) Самые крупные числа будут сосредоточены в одном месте при любом действии игрока (кроме сталкивания кубов вверх);
• 2) Игровое поле будет систематизировано. Два нижних поля превратятся в зону накопления чисел, верхняя же часть квадрата станет местом их сортировки;
• В-третьих — тщательно следите за каждым своим ходом. Прохождение 2048 занимает около 20-25 минут. За это время можно неоднократно ошибиться и испортить даже самую благоприятную картину.

Наконец — если ошибка все же была допущена (геймер случайно направил фигуры вверх, или образовал «проем в нижнем ряду») изучите сложившуюся ситуацию. В первые 5-7 минут игры подобные промахи можно исправить. Далее в 90 % случаев они превращаются в вердикт, гласящий о вашем поражении. В такой ситуации лучше не тратить время и начать все с нуля.

Подбивая итоги

Игра получилась на славу. Простой и понятный интерфейс, отсутствие лишних деталей и ее простота (геймеру достаточно 1-2 минут, что бы разобраться в геймплее) стали главными причинами огромной популярности данного проекта “2048”.

Попробуйте воспользоваться простейшей стратегией. Есть простой способ – двигайте плитки поочередно вверх и вправо до тех пор, пока у вас не будет выбора, кроме как сдвинуть их влево (то есть когда плитки не реагируют на ваши действия). Затем сдвиньте их влево и продолжайте следовать той же тактике вверх/вправо. Это не гарантирует вам победу – в действительности вообще маловероятно, что так вы сможете победить. Однако таким образом вы сможете заработать много очков. С этой тактики можете и начать.

Сосредоточьтесь на угле. Есть одна распространенная техника среди игроков – формирование плитки с наибольшим номером в каком-то определенном угле. Неважно, какой угол вы предпочтете, но как только угол выбран, необходимо его придерживаться.

• После того как вы выбрали угол, убедитесь, что последний ряд (сверху или снизу, зависит от того, какой угол вы выбрали) всегда заполнен. Сдвигайте плитки вверх или вниз, соответственно, чтобы сформировать большее число.
• Сдвигайте плитки по направлению к углу, чтобы получить большее число.

Используйте технику "Мансини" (довольно распространенная техника, но в одной статье она была названа этим именем). Она заключается в формировании цепей плиток, для того чтобы достичь большего числа в верхнем углу поля.

• Начните с движения из стороны в сторону, перемещая плитки то влево, то вправо, пока у вас не закончатся варианты. В результате ваше поле будет состоять из двоек, четверок и восьмерок.
• Когда поле будет заполнено, начните сталкивать числа по направлению к верхней части поля. Когда появится возможность – соедините плитки, чтобы получить большее число.
• Когда вы больше не сможете двигать клетки вверх, снова перемещайте их влево и вправо. Продолжайте в том же духе, сфокусируйтесь на верхнем угле, в котором вы сформируете большее число.
• Старайтесь формировать цепочки, чтобы получить большее число. Это тактика в особенности подходит для первого и второго ряда: старайтесь построить такую последовательность, чтобы в результате, используя движения влево/вправо и вверх, вы получили большее число.
• Лучше соединять малые числа так, чтобы сформировать цепочку, чем стараться работать над увеличением числа на какой-то одной плитке. Тактика формирования цепи позволит вам продвинуться дальше, чем стратегия одной большой плитки.
• Придерживайтесь системы: двигайте плитки из стороны в сторону, соединяя малые плитки вместе, затем сдвигайте их вверх, чтобы получить большее число, выберите свой "большой" угол.

Избегайте ситуации, когда плитка с большим числом оказывается посередине. Если вы нацелены на то, чтобы сформировать большее число в верхнем углу, делайте все что угодно, но не сдвигайте плитки вниз. Аналогично, если вы выбрали нижний угол, не сдвигайте плитки вверх. Если вы это сделаете, плитки с меньшим числом (2 или 4) вклинятся в ряд с "наибольшим числом", а это плохо.

• Если у вас нет выбора, вы можете сдвинуть плитки в другую сторону (вверх или вниз), но старайтесь избегать такой ситуации. Если ничего другого не остается, постарайтесь сформировать последовательность из больших чисел в ряду с крупнейшей плиткой.

Библиотека LWJGL (версии 2.x.x) для работы с графикой (опционально). Обратите внимание, что для LWJGL версий выше 3 потребуется написать код, отличающийся от того, что приведён в статье;

Спрайты, т.е. картинки плиток всех возможных состояний (пустая, и со степенями двойки до 2048). Можно нарисовать самому, или скачать использовавшиеся при написании статьи .

FAQ по опыту предыдущих статей

В: Вы что! Это большой проект, за 15 минут такое нельзя накодить!

О: Разумеется, чтобы придумать всё это и написать, у меня ушёл целый вечер и даже немножко ночи. Но прочитать статью и, скопировав из неё код, запустить работающую игру (при этом понимая, что происходит) вполне реально и за 15 минут.

В: Зачем тянуть ради такого простого проекта LWJGL? Гвозди микроскопом!

О: Вся работа с отображением вынесена в два с половиной метода в 2 интерфейса. Вы можете реализовать их на чём хотите, мне же удобнее на LWJGL.

В: А почему код выкладываете архивом? На гитхаб нужно!

В: У меня не получается подключить твою эту LWJGL! Что делать?

О: В прошлые разы у многих возникли с этим вопросом проблемы, поэтому мне показалось уместным посвятить этому немного времени.

Во-первых, выше я дал ссылку на папку с библиотеками на GitHub, которые использую я, чтобы не было путаницы с версиями и вопросов, где найти что-то. Папку из архива требуется поместить в папку проекта и подключить через вашу IDE.

Во-вторых, у многих пользователей InteliJ IDEA возникли проблемы как раз с их подключением. Я нашёл в сети следующий видеогайд:

После того, как я сделал всё в точности по нему, у меня библиотеки подключились корректно и всё заработало.

В: А почему на Java?

О: На чём бы я не написал, можно было бы спросить «Почему именно на X?». Если в комментариях будет реально много желающих увидеть код на каком-то другом языке, я перепишу игру на нём и выложу (только не Brainfuck, пожалуйста).

С чего начать?

Начать стоит с главного управляющего класса, который в нашем проекте находится выше остальных по уровню абстракции. Вообще отличный совет – в начале работы всегда пишите код вида if(getKeyPressed()) doSomething() , так вы быстро определите фронт работ.

/** * Точка входа. Содержит все необходимые действия для одного игрового цикла. */ public static void main(String args) { initFields(); createInitialCells(); while(!endOfGame){ input(); logic(); graphicsModule.draw(gameField); } graphicsModule.destroy(); }

Это наш main() . Что тут происходит, понять несложно – мы инициализируем поля, потом создаём первые две ячейки и, пока игра не закончится, осуществляем по очереди: ввод пользовательских данных (input()), основные игровые действия (logic()) и вызов метода отрисовки у графического модуля (graphicsModule.draw()), в который передаём текущее игровое поле (gameField).

Так как пока мы не знаем, какие поля инициировать, постараемся написать createInitialCells() . Но так как создавать клетки нам пока просто-напросто не в чем, то создадим класс игрового поля.

Создаём игровое поле

Всё наше поле – матрица чисел и методы, позволяющие их изменять (геттеры и сеттеры). Договоримся только, что пустую ячейку мы будем обозначать числом 0. Выглядеть этот класс будет так:

Public class GameField { /** * Состояние всех ячеек поля. */ private int theField; /** * Инициализирует поле и заполняет его нулями */ public GameField(){ theField = new int; for(int i=0; i

Возможно, пока не совсем очевидно, почему нужны именно такие геттеры и сеттеры, это станет ясно в процессе дальнейшей работы (при разработке с нуля следовало бы создать только getState() и setState() , а остальное дописывать потом).

Создаём в поле первые две ячейки

Совсем очевидно, что нам нужно просто вызвать два раза метод создания одной ячейки.

/** * Создаёт на поле начальные ячейки */ private static void createInitialCells() { for(int i = 0; i < COUNT_INITITAL_CELLS; i++){ generateNewCell(); } }

Заметьте, я не пишу вызов одного метода два раза. Для программистов существует одна максима: «Существует только два числа: один и много». Чаще всего, если что-то нужно сделать 2 раза, то со временем может возникнуть задача сделать это и 3, и 4 и куда больше раз. Например, если вы решите сделать поле не 4х4, а 10х10, то разумно будет создавать не 2, а 10 ячеек.

Вы могли заметить, что в коде использована константа COUNT_INITIAL_CELLS . Все константы удобно определять в классе с public static final полями. Полный список констант, который нам потребуется в ходе разработки, можно посмотреть в классе Constants на GitHub.

Теперь постараемся решить вопрос – как в матрице создать ячейку вместо одного из нулей? Я решил пойти по такому пути: мы выбираем случайные координаты, и если там находится пустая ячейка, то создаём новую плитку там. Если там уже есть плитка с числом, то пытаемся создать в следующей клетке (двигаемся вправо и вниз). Обратите внимание, что после хода не может не быть пустых клеток, т.к. ход считается сделанным, когда клетки либо переместились (т.е. освободили какое-то место), либо соединились (т.е. клеток стало меньше, и место снова высвободилось).

Private static void generateNewCell() { int state = (new Random().nextInt(100) <= Constants.CHANCE_OF_LUCKY_SPAWN) ? LUCKY_INITIAL_CELL_STATE: INITIAL_CELL_STATE; int randomX, randomY; randomX = new Random().nextInt(Constants.COUNT_CELLS_X); int currentX = randomX; randomY = new Random().nextInt(Constants.COUNT_CELLS_Y); int currentY = randomY; boolean placed = false; while(!placed){ if(gameField.getState(currentX, currentY) == 0) { gameField.setState(currentX, currentY, state); placed = true; }else{ if(currentX+1 < Constants.COUNT_CELLS_X) { currentX++; }else{ currentX = 0; if(currentY+1 < Constants.COUNT_CELLS_Y) { currentY++; }else{ currentY = 0; } } if ((currentX == randomX) && (currentY==randomY)) { //No place -> Something went wrong ErrorCatcher.cellCreationFailure(); } } } score += state; }

Немного более затратен по времени и памяти другой метод, который тоже имеет право на жизнь. Мы складываем в какую-либо коллекцию (например, ArrayList) координаты всех ячеек с нулевым значением (простым перебором). Затем делаем new Random().nextInt(X) , где X – размер это коллекции, и создаём ячейку по координатам, указанным в члене коллекции с номером, соответствующем результату.

Реализуем пользовательский ввод

Следующим по очереди у нас идёт метод input() . Займёмся им.

Private static void input() { keyboardModule.update(); /* Определяем направление, в котором нужно будет произвести сдвиг */ direction = keyboardModule.lastDirectionKeyPressed(); endOfGame = endOfGame || graphicsModule.isCloseRequested() || keyboardModule.wasEscPressed(); }

Отсюда нам нужно запомнить только, какие интерфейсы (графический и клавиатурный модули) нам нужно создать и какие методы в них определить. Если не запомнили – не волнуйтесь, ворнинги вашей IDE особо забыть не дадут.

Интерфейсы для клавиатурного и графического модулей

Так как многим не нравится, что я пишу эти модули на LWJGL, я решил в статье уделить время только интерфейсам этих классов. Каждый может написать их с помощью той GUI-библиотеки, которая ему нравится (или вообще сделать консольный вариант). Я же по старинке реализовал их на LWJGL, код можно посмотреть в папках graphics/lwjglmodule и keyboard/lwjglmodule .

Интерфейсы же, после добавления в них всех упомянутых выше методов, будут выглядеть следующим образом:

Графический модуль

public interface GraphicsModule { /** * Отрисовывает переданное игровое поле * * @param field Игровое поле, которое необходимо отрисовать */ void draw(GameField field); /** * @return Возвращает true, если в окне нажат "крестик" */ boolean isCloseRequested(); /** * Заключительные действия, на случай, если модулю нужно подчистить за собой. */ void destroy(); }

Клавиатурный модуль

public interface KeyboardHandleModule { /** * Считывание последних данных из стека событий, если можулю это необходимо */ void update(); /** * @return Возвращает направление последней нажатой "стрелочки", * либо AWAITING, если не было нажато ни одной */ ru.tproger.main.Direction lastDirectionKeyPressed(); /** * @return Возвращает информацию о том, был ли нажат ESCAPE за последнюю итерацию */ boolean wasEscPressed(); }

Метод логики

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

Private static void logic() { if(direction!=Direction.AWAITING){ if(shift(direction)) generateNewCell(); direction=Direction.AWAITING; } }

Вы могли заметить, что мы часто используем enum Direction для определения направления. Т.к. его используют различные классы, он вынесен в отдельный файл и выглядит так:

Public enum Direction { AWAITING, UP, DOWN, LEFT, RIGHT }

Давай уже серьёзно. Как нам сдвинуть это чёртово поле?

Самое ядро нашего кода! Вот самое-самое. К слову, спорный вопрос, куда поместить этот метод – в Main.java или в GameField.java ? Я выбрал первое, но это решение нельзя назвать слишком обдуманным. Жду ваше мнение в комментариях.

Очевидно, что должен быть какой-то алгоритм сдвига линии, который должен применяться к каждому столбцу (или строке, зависит от направления) по очереди и менять значения необходимым нам образом. К этому алгоритму мы и будем обращаться из Main.shift() . Так же такой алгоритм (вынесенный в метод) должен определять, изменил он что-то или не изменил, чтобы метод shift() это значение мог вернуть.

/** * Изменяет gameField, сдвигая все ячейки в указанном направлении, * вызывая shiftRow() для каждой строки/столбца (в зависимости от направления) * * @param direction Направление, в котором необходимо совершить сдвиг * @return Возвращает true, если сдвиг прошёл успешно (поле изменилось) */ private static boolean shift(Direction direction) { boolean ret = false; switch(direction) { case UP: case DOWN: /*По очереди сдвигаем числа всех столбцов в нужном направлении*/ for(int i = 0; i< Constants.COUNT_CELLS_X; i++){ /*Запрашиваем очередной столбец*/ int arg = gameField.getColumn(i); /*В зависимости от направления сдвига, меняем или не меняем порядок чисел на противоположный*/ if(direction==Direction.UP){ int tmp = new int; for(int e = 0; e < tmp.length; e++){ tmp[e] = arg; } arg = tmp; } /*Пытаемся сдвинуть числа в этом столбце*/ ShiftRowResult result = shiftRow (arg); /*Возвращаем линию в исходный порядок*/ if(direction==Direction.UP){ int tmp = new int; for(int e = 0; e < tmp.length; e++){ tmp[e] = result.shiftedRow; } result.shiftedRow = tmp; } /*Записываем изменённый столбец*/ gameField.setColumn(i, result.shiftedRow); /*Если хоть одна линия была изменена, значит было изменено всё поле*/ ret = ret || result.didAnythingMove; } break; case LEFT: case RIGHT: /*По очереди сдвигаем числа всех строк в нужном направлении*/ for(int i = 0; i< Constants.COUNT_CELLS_Y; i++){ /*Запрашиваем очередную строку*/ int arg = gameField.getLine(i); /*В зависимости от направления сдвига, меняем или не меняем порядок чисел на противоположный*/ if(direction==Direction.RIGHT){ int tmp = new int; for(int e = 0; e < tmp.length; e++){ tmp[e] = arg; } arg = tmp; } /*Пытаемся сдвинуть числа в этом столбце*/ ShiftRowResult result = shiftRow (arg); /*Возвращаем линию в исходный порядок*/ if(direction==Direction.RIGHT){ int tmp = new int; for(int e = 0; e < tmp.length; e++){ tmp[e] = result.shiftedRow; } result.shiftedRow = tmp; } /*Записываем изменённую строку*/ gameField.setLine(i, result.shiftedRow); /*Если хоть одна линия была изменена, значит было изменено всё поле*/ ret = ret || result.didAnythingMove; } break; default: ErrorCatcher.shiftFailureWrongParam(); break; } return ret; }

Так как этот магический метод с алгоритмом должен будет по сути вернуть два объекта (новую линию и boolean , который будет говорить о наличии изменений в ней), создадим в начале класса Main для такого результата обёртку:

/** * Результат работы метода сдвига shiftRow(). * Содержит изменённую строку и информацию о том, эквивалентна ли она начальной. */ private static class ShiftRowResult{ boolean didAnythingMove; int shiftedRow; }

Можно, конечно. просто возвращать линию, а затем сравнивать её (не забываем, что это нужно делать через метод equals() , а не через ==), но на это будет уходит больше времени (из-за сравнение каждого элемента массива), но меньше памяти (на один boolean).

Самое сердце программы. Метод shiftRow()

Если подумать, то вам предстоит решить задачку - как за наименьшее (линейно зависящее от количества поступающих данных) время произвести с рядом чисел следующие последовательные операции: (1) если в ряде есть нули, их необходимо удалить, (2) если любые два соседних числа равны, то вместо них должно остаться одно число, равное сумме двух равных чисел. И (3) - если число получено через пункт (2), оно не может совмещаться с другими числами.

Если представить себе алгоритм таким образом, то придумать линейное решение будет гораздо легче. Вот какой алгоритм должен получиться:

• Выкидываем все нули - проходимся по всему массиву и копируем элемент в новый массив, только если он не равен нулю. Если вы попробуете удалять эти нули из середины того же массива, алгоритм будет работать за O(n^2).
• Рассмотрим (поставим указатель на) первое число получившегося массива без нулей .
  1. Если с ним можно совместить следующее за ним число (наш указатель +1), то переписываем в новый массив лишь их сумму, затем ставим указатель на третье число (второго уже нет).
  2. Иначе переписываем только первое, и ставим указатель на второе число.

При этом нам необходимо хранить место в возвращаемом массиве, на которое необходимо произвести запись.

А вот как он выглядит в виде кода:

Private static ShiftRowResult shiftRow (int oldRow) { ShiftRowResult ret = new ShiftRowResult(); int oldRowWithoutZeroes = new int; { int q = 0; for (int i = 0; i < oldRow.length; i++) { if(oldRow[i] != 0){ if(q != i){ /* * Это значит, что мы передвинули ячейку * на место какого-то нуля (пустой плитки) */ ret.didAnythingMove = true; } oldRowWithoutZeroes[q] = oldRow[i]; q++; } } } ret.shiftedRow = new int; { int q = 0; { int i = 0; while (i < oldRowWithoutZeroes.length) { if((i+1 < oldRowWithoutZeroes.length) && (oldRowWithoutZeroes[i] == oldRowWithoutZeroes) && oldRowWithoutZeroes[i]!=0) { { ret.didAnythingMove = true; ret.shiftedRow[q] = oldRowWithoutZeroes[i] * 2; i++; } else { ret.shiftedRow[q] = oldRowWithoutZeroes[i]; } q++; i++; } } }

Игра 2048 стала однозначным хитом среди своих конкурентов, когда вышла в свет, она вызвала вокруг себя огромный ажиотаж, множество людей постили в социальных сетях сотни сообщений о своих рекордах в этой игре. Чем же она так затянула всех? Простота геймплея, красивый и приятный глазу дизайн - это игра, в которой приходится значительно подумать для того, чтобы победить, ну а как иначе?

История появления игры

Данная игра, как бывает иногда, была создана не с целью обогащения, для автора она носила лишь развлекательный и познавательный характер. Итальянский 19-летний парень однажды вечером решил проверить свои знания и написать игру. Идея не полностью его, он модифицировал очень похожую на эту игру. Затем она стала набирать бешенную популярность, буквально за неделю о ней узнал весь мир, и всё благодаря простоте и затягивающему геймплею. Данная игра имеет открытый исходный код, который может посмотреть любой желающий, в том числе и для обучения. Но нам не нужно обучение чему-либо, кроме данной игры. Ведь мы здесь и хотим побеждать. Так каков секрет 2048, как выиграть в неё?

Суть игры

Как выиграть? Для начала необходимо разобраться в самой игре и её правилах. Всё предельно просто. Поле, размером 4 на 4 кубика. В начале игры и при каждом ходе появляются в случайных местах кубики с цифрами 2 или 4 внутри (двойка появляется чаще). В игре существует 4 действия, вверх-вниз-влево-вправо. Каждым из них игрок двигает все кубики на игровом поле в определенную сторону, если им есть куда передвинуться. Если при передвижении между собой встречаются два кубика с одинаковой цифрой - они объединяются, и на их месте появляется в два раза большая ячейка. Например, сдвинув вместе две двойки, мы получим четвёрки, из двух четвёрок получим восьмёрку, а из двух восьмёрок - 16. Знатоки математики сразу заметили, что все эти цифры - степени двоек. И учитывая то, что 2048 - это 2 в 11 степени, придётся знатно потрудиться.

Как выиграть в 2048: схема

Существует множество схем и стратегий для победы в эту игру. Тщательно почитайте и выберите ту, что понравится именно вам. А можете попробовать все и для себя найти самую эффективную и именно ту, что позволит вам узнать ответ на вопрос о том, если есть игра 2048, как выиграть. Можно заметить, что стратегии идут по усложнению, от самой простой к самой сложной и эффективной. Поэтому идите по порядку, и вы обязательно победите.

Список стратегий для победы в 2048

В заключение

На этом можно закончить данную статью про игру 2048. Как выиграть в неё, вы теперь
знаете, и пора применить знания на практике. Скачивайте данную игру на свой телефон, чтобы она всегда была под рукой. Или же поиграйте в неё прямо сейчас на своем компьютере, ведь когда она получила свою популярность, множество разработчиков переделали её на свой лад. И теперь в неё можно поиграть на сотнях сайтов, с разными вариациями, начиная от кусочков пиццы, которые превращаются в другую еду, заканчивая различными актерами.