История появления игры. В: А почему на Java
Игра 2048 - это головоломока для Android и IOS устройств, а также для компьтера, созданная не по принципу известной нам игры пятнашки, а по принципу соединения одинаковых плиток с числами, чтобы получить плитку с цифрой 2048. Смысл и суть игры 2048 получить плитку с цифрой 2048.
В верхней части игры есть табло с очками, и если там окажется цифра 2048 или больше, то это не будет означать что вы выиграль! Только полученная на поле цифра 2048 укажет на выигриш! Чтобы выиграть в игре 2048 запаситесь терпением!
Как правильно играть в головоломку 2048?
Правила игры 2048 очень просты.
- Двигайте цифры вверх вниз влево или право соединяя одинаковые цифры.
- Для того, чтобы передвигать цифры водите пальцем в нужную сторону или, в случае игры с компьютера, нажимайте по клавишам ← ↓ →
- Чтобы выиграть в головоломке 2048 необходимо выбрать тактику, придумать свою стратегию или алгоритм прохождения. А как иначе!? Это же головоломка!
Как скачать и установить игру 2048?
Скачать игру 2048 можно бесплатно !
- Заходим в андроид маркет (в списке програм это Play Маркет ) или App Store.
- В строку поиск вводим 2048
- В появившемся списке выбираем игру и нажимаем установить
.
Разработчики регулярно добавляют в маркет обновления или новые версии для этой игры, в которых появляются новые уровни для прохождения. Например существуют версии: 2048 super, 4096 и 8192, но во всех них алгоритм действия по одной и той-же схеме.
Обновить игру 2048 нужно в томже маркете, где вместо значка установить у вас будет появляться обновить .
Кроме приложений для различных мобильных устройств и планшетов, в эту игру можно поиграть и с компьютера . Достаточно зайти на сайт: www.game2048.ru и собрать заветную цифру 2048 в онтайн игре))
Общая информация приложения 2048
Подсказки как пройти игру 2048
Как правильно играть в 2048? Как собрать 2048? Как выиграть в эту игру? Эти вопросы и другие секреты прохождения попытаемся описать ниже.
Секрет прохождения игры 2048 заключается в том, чтобы сосредоточить кубики в одной стороне из чего можно извлечь слудеющие:
Секрет № 1 прохождения игры 2048:
Двигайте цифру только в 3 направлениях. Например Влево, Вниз и Вправо.Секрет № 2 прохождения игры 2048:
Пытайтесь не использовать четвертое направление (Вверх) даже если вам кажется что это более подходящий момент.
Секрет № 3 прохождения игры 2048:
Испольуйте 4 направления только в случае, если все ряды кубов полные (старайтесь избегать этого) и если действие отличное от четвёртого "нежелательного" движения приводит к проигрышу.
Секрет № 4 прохождения игры 2048:
Если уж так получилось что вы использовали 4 направление, сразу же выполняйте обратное ему, чтобы вернуть игру в прежний лад.
- Если выпавшая двойка с левого или с правого края, расстраиваться не стоит вы с опытом поймёте как это компенсировать в дальнейшем продолжении игры после такого инсцидента.
- Если же выпавшая двойка приходится на один из средних столбиков, тут можно начинать игру заново.
Секрет № 5 прохождения игры 2048:
Старайтесь в игре больше всего нажимать собственно клавишу, которая прибивает к стороне, в премере это клавиша Вниз.
Секрет № 6 прохождения игры 2048:
Для этономии времени на первых 30-60 секундах игры можете незадумываясь быстро нажимать:
Влево Вниз Вправо Вниз и повторять эту комбинацию очень быстро. Не забывайте следить за тем что происходит, чтобы исключить проигрыш.
Важно: многие игроки жалуются на постоянно мелькающую рекламу в самом низу экрана. Отключить ее можно простым способом: перед тем зайти в приложение 2048 отключите интернет на своем устройстве. Без доступа к интернету реклама не найдет источник и не появится.
Требуются еще подсказки как пройти головоломку 2048? Спрашивайте! А также пишите свою тактику игры.
Подсказки и ответы на другие:
. Многое из представленного в них является своеобразной классикой развивающих игр, но и за новинками мы стараемся следить. Поэтому сегодня предлагаем вам поиграть в уже известную во всём мире, и приобретающую ещё большую популярность с каждым днём онлайн игру – 2048 .Она действительно увлекательна, при этом прекрасно подходит не только для того, чтобы скоротать время в очереди или общественном транспорте, но и сделать это с пользой для себя. 2048 отлично развивает , навыки стратегического планирования и пространственное воображение. Ниже приведено детальное описание игры, её правил, а также даны ответы на вопросы как выиграть и какую стратегию игры выбрать.
История создания
Это не совсем сравнимо, но и как множество других открытий и изобретений в области компьютерного ПО, 2048 была разработана не с целью создания успешного коммерческого проекта. Её автор, молодой итальянский программист и веб-разработчик Габриэле Чирулли, решил с пользой провести выходные и попробовать свои силы в написании программ на JavaScript. За основу он взял идею нескольких других цифровых головоломок (в частности Threesи 1024). К концу выходных, а именно 9 марта 2014 г. Г. Чирулли посредством Твиттера поделился ссылкой на своё творение, которое загрузил на Github, с друзьями. Дальше произошло то, что могло произойти только в информационную эпоху – меньше, чем за неделю в 2048 сыграло больше 4 млн. людей. 19-летний разработчик был поражён успехом игры, но зарабатывать на ней деньги не собирался. В интервью он честно говорил, что идея приложения не была оригинальной, он сделал лишь модификацию. Несмотря на это, 2048 по популярности значительно опережала аналогичные игры, вышедшие раньше, а после того, как появилась возможность скачать версии для Androidи iOS, спустя 2 месяца после первого релиза, о ней, без преувеличений, заговорил весь мир. Не последнюю роль здесь, конечно же, сыграл тот факт, что приложение распространялось бесплатно. Даже такие издания как «Times», «Wall Street Journal» и «Business Insider» вышли с положительными отзывами о данной компьютерной игре.
Любите подобные загадки, игры, головоломки и тесты? Получите ко всем интерактивным материалам на сайте, чтобы развиваться эффективнее.
Помимо оригинального варианта 2048 со временем появилось достаточно много дополнений и даже разновидностей игры, ведь она распространяется с открытым исходным кодом. Так, во многих версиях появились списки лидеров, управление было адаптировано для сенсорных экранов. Было выпущено несколько модификаций, где вместо стандартной плитки с числами использовались фигуры из Тетриса, изображения персонажей сериала «Доктор Кто» и т.д. Созданы даже отдельные сайты-конструкторы, где любой желающий может использовать в качестве плитки всё, что угодно. Так, студенты одного вуза создали версию с фотографиями своих преподавателей, где плитке с номиналом «2» соответствовало фото методистки, а «2048» – декана факультета.
Кроме того, код игры 2048 также используется в образовательных целях для обучения программированию.
Описание и правила игры
Игровое поле для 2048 представляет собой квадрат 4×4 (многие российские пользователи сразу углядели в этом общий момент с другой давно популярной у нас игрой «пятнашки»), на котором в стартовой позиции две плитки (иногда – тайлы, от английского «tile» – «плитка») уже открыты. Они могут располагаться как угодно, варианты начальной расстановки – «2» и «2», «2» и «4», «4» и «4» (реже всего). «Костяшки» можно перемещать в одну из четырёх сторон (если этому не мешает расположение), при этом, когда две плитки одинакового номинала сталкиваются друг с другом, то стают одним тайлом, значение которого удваивается. За один ход плитка может складываться в разных местах игрового поля, но лишь один раз увеличивать свой номинал. Другими словами, если подряд расположены «2», «2» и «4», то за ход можно объединить только «2» и «2» в «4», а получившуюся «4» с блоком такого же значения – лишь во время следующего хода.
Особенностью 2048 является то, что движется всё игровое поле до границы, а не отдельные столбцы или строчки. После каждого такого хода на случайной пустой клетке появляется новая плитка номинала «2» (с вероятностью 90%) или «4» (с вероятностью 10%). Игра считается проигранной, если у вас не осталось ходов (все клетки заполнены «костяшками», возможностей их объединить нет). Для победы в изначальной версии игры нужно было собрать тайл номиналом «2048» (откуда собственно и название). Позже алгоритм был несколько изменён, что позволило продолжать игру до получения максимально возможного значения плитки – 2 17 .
В игре также предусмотрен подсчёт очков – суммы всех соединённых за игру плиток. Текущие очки за игру и лучший персональный результат отображаются в правом верхнем углу.
В старой версии помимо функции перезапуска игры с начала, была также функция UNDO– отмены сделанных ходов, но на момент написания статьи разработчик её убрал.
Всё вышеописанное может показаться довольно сложным на словах, на деле же достаточно пары минут, чтобы детально разобраться с правилами и принципом игры.
2 способа как победить в 2048
2048 – простая цифровая головоломка. Но это лишь на первый взгляд. Сама суть действительно такова – что может быть проще, чем складывать плитки меньшего достояния с целью получить в конце нужную плитку большего номинала? В этом был уверен и сам Г. Чирулли, придумавший концепцию. Правда, 11 марта (спустя 2 дня после представления игры как готового продукта) он в социальной сети сообщил, что потратил 16 часов на игру, а добиться нужного результата так ни разу и не смог.
В этом же убедились и многие другие, кто хотя бы пару раз пробовал сыграть. Стало очевидно, что без определённой тактики выиграть невозможно. Некоторое время спустя, которое понадобилось фанатам и другим заинтересованным на то, чтобы провести и проверить их на практике, появилось пару выигрышных стратегий. С существенной поправкой на то, что 100% действующей методики, как набора готовых решений, следуя которым можно набрать заветные «2048», нет. Они задают лишь верный алгоритм, но многое остаётся зависимым от совершаемых игроком действий, а порой и игровой раскладки.
Стратегия «змейка»
Стратегия «змейка» получила своё название на русскоязычных форумах от принципа одноименной старой игры. Её суть в расположении подряд блоков с ниспадающим номиналом (512-256-128-64). Разберёмся более подробно.
Первое что следует сделать – определиться с рабочей областью, тем участком игрового поля, где вы собственно и будете собирать «2048». Им может быть любой из углов. На рисунке выше показан вариант с расположением плитки наибольшего значения в левом нижнем углу. Его и возьмём за отправную точку. Суть всего метода в том, чтобы исключить одно из направлений движения. В нашем случае это «вверх». В этом нет никакого скрытого сакрального смысла, просто, если вы поднимете все блоки вверх (особенно на поздних этапах игры, когда большая часть поля уже занята тайлами), на месте в углу с высокой долей вероятности может возникнуть «2» или «4». Это сломает стратегию, ведь «костяшку» такого значения очень тяжело будет собрать, особенно если она окружена плитками достояния 64 и больше. В противном же случае, собирая именно в угловой клетке наибольшее число, вероятность победы равняется 80%. Остальные блоки нужно стараться собирать в этой же строке по принципу уменьшения их номинала (как показано на рисунке). Это позволит вам, используя большую часть игрового поля, собирать нужные плитки и поочерёдно их соединять, что очень удобно.
Для визуального представления о том, как реализовать эту стратегию – смотрите видео. Помните, с первого раза не получается практически ни у кого.
Стратегия приоритетного столбца
Простой способ, описанный на Хабрахабре . Суть примерно та же, что и в «змейке», но реализация другая. Условно делим игровое поле на 4 столбца (на картинке показано слева направо, но можно так, как удобно вам), нумеруем их – крайний левый – первый, крайний правый – четвертый. При сложении плиток следуем принципу: блоки с наибольшим значением должны быть в первом столбце, во втором числа меньше, чем в первом, в третьем меньше, чем во втором и т.д. Наибольшими тайлами мы заполняем весь первый столбец. Как и в случае с предыдущей методикой, двигать его нельзя (что касается нашего примера, это движение «вправо»). На основе этого строится стратегия игры – выбирать стоит тот ход, который увеличивает номинал первых столбцов. Существенный нюанс – следует так планировать игру, чтоб новое появившееся число не стало четвертым в столбце, без возможности его соединить, и не привело к ситуации, когда другого выхода кроме движения «вправо» не останется.
Как это выглядит на практике:
Рекорды
Плитка со значением «2048» означает, что вы победили, но игру после этого можно продолжить. Максимально возможный номинал блока – 131 072 (или 2 17). Кроме того, много игроков, следуя зову заложенной в человеческой природе жажде к достижениям, соревнуются в наборе наибольшего количества очков. Максимальный результат, который можно набрать – 3 932 100, но это идеальный случай, а так – каждая новая «4» уменьшает эту сумму на 4. В Интернете встречается много видеозаписей и снимков экрана с запечатлёнными на них рекордными счетами. Но сказать, не использовался ли для их достижения скрипт для автоматического прохождения игры, сложно.
Попробуйте воспользоваться простейшей стратегией. Есть простой способ – двигайте плитки поочередно вверх и вправо до тех пор, пока у вас не будет выбора, кроме как сдвинуть их влево (то есть когда плитки не реагируют на ваши действия). Затем сдвиньте их влево и продолжайте следовать той же тактике вверх/вправо. Это не гарантирует вам победу – в действительности вообще маловероятно, что так вы сможете победить. Однако таким образом вы сможете заработать много очков. С этой тактики можете и начать.
Сосредоточьтесь на угле. Есть одна распространенная техника среди игроков – формирование плитки с наибольшим номером в каком-то определенном угле. Неважно, какой угол вы предпочтете, но как только угол выбран, необходимо его придерживаться.
- После того как вы выбрали угол, убедитесь, что последний ряд (сверху или снизу, зависит от того, какой угол вы выбрали) всегда заполнен. Сдвигайте плитки вверх или вниз, соответственно, чтобы сформировать большее число.
- Сдвигайте плитки по направлению к углу, чтобы получить большее число.
Используйте технику "Мансини" (довольно распространенная техника, но в одной статье она была названа этим именем). Она заключается в формировании цепей плиток, для того чтобы достичь большего числа в верхнем углу поля.
- Начните с движения из стороны в сторону, перемещая плитки то влево, то вправо, пока у вас не закончатся варианты. В результате ваше поле будет состоять из двоек, четверок и восьмерок.
- Когда поле будет заполнено, начните сталкивать числа по направлению к верхней части поля. Когда появится возможность – соедините плитки, чтобы получить большее число.
- Когда вы больше не сможете двигать клетки вверх, снова перемещайте их влево и вправо. Продолжайте в том же духе, сфокусируйтесь на верхнем угле, в котором вы сформируете большее число.
- Старайтесь формировать цепочки, чтобы получить большее число. Это тактика в особенности подходит для первого и второго ряда: старайтесь построить такую последовательность, чтобы в результате, используя движения влево/вправо и вверх, вы получили большее число.
- Лучше соединять малые числа так, чтобы сформировать цепочку, чем стараться работать над увеличением числа на какой-то одной плитке. Тактика формирования цепи позволит вам продвинуться дальше, чем стратегия одной большой плитки.
- Придерживайтесь системы: двигайте плитки из стороны в сторону, соединяя малые плитки вместе, затем сдвигайте их вверх, чтобы получить большее число, выберите свой "большой" угол.
Избегайте ситуации, когда плитка с большим числом оказывается посередине. Если вы нацелены на то, чтобы сформировать большее число в верхнем углу, делайте все что угодно, но не сдвигайте плитки вниз. Аналогично, если вы выбрали нижний угол, не сдвигайте плитки вверх. Если вы это сделаете, плитки с меньшим числом (2 или 4) вклинятся в ряд с "наибольшим числом", а это плохо.
- Если у вас нет выбора, вы можете сдвинуть плитки в другую сторону (вверх или вниз), но старайтесь избегать такой ситуации. Если ничего другого не остается, постарайтесь сформировать последовательность из больших чисел в ряду с крупнейшей плиткой.
Итак, алгоритм простой. Вам нужно собирать максимальное число в левом нижнем углу. При этом нельзя двигать кубики вверх! Иначе есть риск появления там маленьких цифр, которые вы не сможете сложить в большие, и они будут у вас просто занимать место. То есть, у вас будут выстраиваться, например, 1024, 512, 256,128. И, таким образом, вы в течении некоторого времени сложите заветный кубик 2048.Нужно внимательно следить за тем, чтобы в нижнем ряду (особенно в левом углу) не появлялось кубиков 2,4,8 и т. д. Иначе вам будет очень сложно собрать из них большие цифры. Это может помешать вам в достижении победы. Вот скрин: .
Также вы можете использовать такие стратегии:
Стратегии 2048
Для того чтобы выиграть в эту игру за меньшее количество ходов (да и вообще, чтобы просто выиграть ее), подумайте над стратегией. От того, как вы начнете игру, зависит многое и основные действия лучше продумать еще в самом начале.
1)Стратегия «Змейка»
Это самая простая стратегия – нужно просто последовательно жать четыре кнопки управления. Например, «Вверх», «Вправо», «Вниз», «Влево», повторить. Эта стратегия почти не требует усилий, и таким образом можно набрать около 512 очков, но скорее всего, в заполненном поле вы уже не сможете сделать никаких действий. Можно начать с этой стратегии, чтобы познакомиться с игрой и понять механизм действия, но для победы она не особо эффективна.
2)Стратегия 3ех кнопок (стратегия одного столбца)
Эта стратегия сложнее, но и более результативная. При сдвигании плиток нужно пользоваться только тремя кнопками управления. То есть, например, вы пользуетесь только кнопками «Вверх», «Вправо» и «Влево», а кнопку «Вниз» не нажимаете вообще. Таким образом, плитки суммируются с одной стороны поля и их легче «копить», но у этой стратегии есть и недостаток – при достижении определенной планки, приходится использовать 4ую кнопку, и ячейки с большим номиналом неизбежно сдвигаются в сторону. Там, где они раньше находились, появляются новые двойки или четверки, которые сложно объединить с большими числами, которые стоят рядом. Если вам повезет – хорошо, нет – придется начать все заново.
3) Стратегия одного угла
Эта стратегия похожа на предыдущую, но она подразумевает использование двух игровых кнопок – так, чтобы большие цифры копились в углу. Для этого нужно выбрать угол, например, левый нижний и в нем копить ячейки, нажимая преимущественно «Влево» и «Вниз», но, опять же, в определенный момент потребуется сдвинуть ячейки в другую сторону – влево или вверх. Для того чтобы большие цифры не меняли положения, лучше, чтобы ряд, в котором они находятся, был полностью заполнен (и по вертикали и по горизонтали) разными значениями (чтобы они не слились в одно).
4)Стратегия одного столбца с приоритетом
Основа этой стратегии такая же, как и у второй. Вы копите большие значения в одной стороне (например, внизу), и тогда вы вообще не используете кнопку «Вверх». При этом при использовании оставшихся трех кнопок, вы держите в приоритете движения в сторону того самого столбца с большими значениями. Если это нижняя строка, то значит в ситуации, когда есть возможность объединить ячейки в нескольких местах, вы всегда сдвигаете их вниз, а не вправо или влево.
5)Стратегия накопления по нарастающей (как я выше писал)
При использовании этой стратегии важен порядок, в котором находятся ячейки с цифрами. Они должны идти от большего значения к меньшему. В общем читайте все как я написал в начале ответа.
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++;
}
}
}
Создаём в поле первые две ячейки
Реализуем пользовательский ввод
Интерфейсы для клавиатурного и графического модулей
Графический модуль
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()