Стратегия и тактика игры. Способ трех кнопок
Попробуйте воспользоваться простейшей стратегией. Есть простой способ – двигайте плитки поочередно вверх и вправо до тех пор, пока у вас не будет выбора, кроме как сдвинуть их влево (то есть когда плитки не реагируют на ваши действия). Затем сдвиньте их влево и продолжайте следовать той же тактике вверх/вправо. Это не гарантирует вам победу – в действительности вообще маловероятно, что так вы сможете победить. Однако таким образом вы сможете заработать много очков. С этой тактики можете и начать.
Сосредоточьтесь на угле. Есть одна распространенная техника среди игроков – формирование плитки с наибольшим номером в каком-то определенном угле. Неважно, какой угол вы предпочтете, но как только угол выбран, необходимо его придерживаться.
- После того как вы выбрали угол, убедитесь, что последний ряд (сверху или снизу, зависит от того, какой угол вы выбрали) всегда заполнен. Сдвигайте плитки вверх или вниз, соответственно, чтобы сформировать большее число.
- Сдвигайте плитки по направлению к углу, чтобы получить большее число.
Используйте технику "Мансини" (довольно распространенная техника, но в одной статье она была названа этим именем). Она заключается в формировании цепей плиток, для того чтобы достичь большего числа в верхнем углу поля.
- Начните с движения из стороны в сторону, перемещая плитки то влево, то вправо, пока у вас не закончатся варианты. В результате ваше поле будет состоять из двоек, четверок и восьмерок.
- Когда поле будет заполнено, начните сталкивать числа по направлению к верхней части поля. Когда появится возможность – соедините плитки, чтобы получить большее число.
- Когда вы больше не сможете двигать клетки вверх, снова перемещайте их влево и вправо. Продолжайте в том же духе, сфокусируйтесь на верхнем угле, в котором вы сформируете большее число.
- Старайтесь формировать цепочки, чтобы получить большее число. Это тактика в особенности подходит для первого и второго ряда: старайтесь построить такую последовательность, чтобы в результате, используя движения влево/вправо и вверх, вы получили большее число.
- Лучше соединять малые числа так, чтобы сформировать цепочку, чем стараться работать над увеличением числа на какой-то одной плитке. Тактика формирования цепи позволит вам продвинуться дальше, чем стратегия одной большой плитки.
- Придерживайтесь системы: двигайте плитки из стороны в сторону, соединяя малые плитки вместе, затем сдвигайте их вверх, чтобы получить большее число, выберите свой "большой" угол.
Избегайте ситуации, когда плитка с большим числом оказывается посередине. Если вы нацелены на то, чтобы сформировать большее число в верхнем углу, делайте все что угодно, но не сдвигайте плитки вниз. Аналогично, если вы выбрали нижний угол, не сдвигайте плитки вверх. Если вы это сделаете, плитки с меньшим числом (2 или 4) вклинятся в ряд с "наибольшим числом", а это плохо.
- Если у вас нет выбора, вы можете сдвинуть плитки в другую сторону (вверх или вниз), но старайтесь избегать такой ситуации. Если ничего другого не остается, постарайтесь сформировать последовательность из больших чисел в ряду с крупнейшей плиткой.
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 . Интерфейсы же, после добавления в них всех упомянутых выше методов, будут выглядеть следующим образом: Вполне понятно, что если было определено направление сдвига, то нужно произвести в этом направлении сдвиг – в этом вся суть игры. Также, если сдвиг произвести удалось, необходимо создать новую ячейку. Направление для нового сдвига должно снова стать неопределённым – до следующего пользовательского ввода. 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). Если подумать, то вам предстоит решить задачку - как за наименьшее (линейно зависящее от количества поступающих данных) время произвести с рядом чисел следующие последовательные операции: (1) если в ряде есть нули, их необходимо удалить, (2) если любые два соседних числа равны, то вместо них должно остаться одно число, равное сумме двух равных чисел. И (3) - если число получено через пункт (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 - это головоломока для Android и IOS устройств, а также для компьтера, созданная не по принципу известной нам игры пятнашки, а по принципу соединения одинаковых плиток с числами, чтобы получить плитку с цифрой 2048. Смысл и суть игры 2048 получить плитку с цифрой 2048. В верхней части игры есть табло с очками, и если там окажется цифра 2048 или больше, то это не будет означать что вы выиграль! Только полученная на поле цифра 2048 укажет на выигриш! Чтобы выиграть в игре 2048 запаситесь терпением! Правила игры 2048 очень просты. Скачать игру 2048 можно бесплатно
! Разработчики регулярно добавляют в маркет обновления или новые версии для этой игры, в которых появляются новые уровни для прохождения. Например существуют версии: 2048 super, 4096 и 8192, но во всех них алгоритм действия по одной и той-же схеме. Обновить игру 2048 нужно в томже маркете, где вместо значка установить
у вас будет появляться обновить
. Как правильно играть в 2048? Как собрать 2048? Как выиграть в эту игру? Эти вопросы и другие секреты прохождения попытаемся описать ниже. Секрет прохождения игры 2048 заключается в том, чтобы сосредоточить кубики в одной стороне из чего можно извлечь слудеющие: Пытайтесь не использовать четвертое направление (Вверх) даже если вам кажется что это более подходящий момент. Испольуйте 4 направления только в случае, если все ряды кубов полные (старайтесь избегать этого) и если действие отличное от четвёртого "нежелательного" движения приводит к проигрышу. Если уж так получилось что вы использовали 4 направление, сразу же выполняйте обратное ему, чтобы вернуть игру в прежний лад. Старайтесь в игре больше всего нажимать собственно клавишу, которая прибивает к стороне, в премере это клавиша Вниз. Для этономии времени на первых 30-60 секундах игры можете незадумываясь быстро нажимать: Влево Вниз Вправо Вниз и повторять
эту комбинацию очень быстро. Не забывайте следить за тем что происходит, чтобы исключить проигрыш.
Важно:
многие игроки жалуются на постоянно мелькающую рекламу в самом низу экрана. Отключить ее можно простым способом: перед тем зайти в приложение 2048 отключите интернет на своем устройстве. Без доступа к интернету реклама не найдет источник и не появится. Требуются еще подсказки как пройти головоломку 2048? Спрашивайте! А также пишите свою тактику игры. Подсказки и ответы на другие:
2048
— это игра, где отлично воссоединились традиционный тетрис и пятнашки. После запуска игры все начинают задаваться вопросом: “Как играть 2048”, для ознакомления с правилами и победной стратегией читайте далее. Габриэль Черулли, создатель игры, предлагает игрокам поле с 16 клеточками, на котором с каждым ходом появляется цифра два. Суть заключается в том, что нужно объединять квадратики с одинаковыми значениями до тех пор, пока не получиться цифра 2048. Конечная цель игры — плитка с цифрами 2048. Добиться таких результатов, можно лишь одним способом, а именно просчитывая все ходы наперед. Разберём подробно, как играть 2048, начнем с простых правил. Так, например, в начале игры вам выдается два кирпичика с цифрой «2», нажимая кнопочку вверх, вправо, влево или вниз, все ваши кирпичики будут смещаться в ту же сторону. Но, при соприкосновении клеточек с одним и тем же номиналом, они объединяются и создают сумму вдвое больше. Рассмотрим на примере основное правило. Так, допустим, у вас два кирпичика «2», сместите их так, чтобы они находились рядом и повторите процедуру, пока у вас не получиться цифра «4». Получилось? Дальше необходимо действовать тем же способом и теперь уже собирать клеточку «8» из двух «4». Для того чтобы играть 2048 на компьютере достаточно лишь спуститься ниже. Игра заканчивается тогда, когда все пустые ячейки заполнены, и вы больше не можете передвигать клеточки ни в одну из сторон. Ну, или когда на одном из кубов, наконец, появилась заветная цифра 2048. На то, чтобы пройти всю игру 2048 необходимо потратить всего лишь 20 — 25 минут, при условии, конечно, что не будет допущено страшных и непоправимых ошибок при прохождении, а для этого мы рассмотрим тактику и несколько стратегий. Следует сразу отметить, что игра предназначена для тех, кто имеет аналитический склад ума и обожает ребусы и головоломки. Логика — понятие, без которого играть в 2048 не возможно, но мы все же дадим несколько советов, согласно которым вы сможете пройти ее от начала и до конца. Играть 2048 онлайн: Ну, конечно же, в каждой игре непременно должны быть секреты, которые помогут добиться высоких результатов. Не исключением является и игра 2048, как играть 2048 и получить эту заветную цифру, рассмотрим несколько из них: Воспользовавшись этими простыми советами, вы сможете без труда пройти игру 2048 и увидите именно эту цифру на победном кирпичике. Удачи.Создаём в поле первые две ячейки
Реализуем пользовательский ввод
Интерфейсы для клавиатурного и графического модулей
Графический модуль
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();
}
Метод логики
Давай уже серьёзно. Как нам сдвинуть это чёртово поле?
Самое сердце программы. Метод shiftRow()
Как правильно играть в головоломку 2048?
Как скачать и установить игру 2048?
Кроме приложений для различных мобильных устройств и планшетов, в эту игру можно поиграть и с компьютера . Достаточно зайти на сайт: www.game2048.ru и собрать заветную цифру 2048 в онтайн игре))Общая информация приложения 2048
Подсказки как пройти игру 2048
Секрет № 1 прохождения игры 2048:
Двигайте цифру только в 3 направлениях. Например Влево, Вниз и Вправо.
Секрет № 2 прохождения игры 2048:
Секрет № 3 прохождения игры 2048:
Секрет № 4 прохождения игры 2048:
Секрет № 5 прохождения игры 2048:
Секрет № 6 прохождения игры 2048:
Правила игры в 2048
Тактика и стратегия
Секреты и хитрости