{"draftJsState":{"blocks":[{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Нам, как обычно, понадобятся:","type":"header-three","key":"5mp32"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"30 минут свободного времени;","type":"unordered-list-item","key":"b8hql"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":3,"offset":32},{"key":1,"length":7,"offset":53}],"inlineStyleRanges":[],"text":"Настроенная рабочая среда, т.е. JDK и IDE (например, Eclipse);","type":"unordered-list-item","key":"7ehot"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":5,"offset":11}],"inlineStyleRanges":[],"text":"Библиотека LWJGL (версии 2.x.x) для работы с графикой (опционально). Обратите внимание, что для LWJGL версий выше 3 потребуется написать код, отличающийся от того, что приведён в статье;","type":"unordered-list-item","key":"d535o"},{"data":{},"depth":0,"entityRanges":[{"key":3,"length":37,"offset":133}],"inlineStyleRanges":[],"text":"Спрайты, т.е. картинки плиток всех возможных состояний (пустая, и со степенями двойки до 2048). Можно нарисовать самому, или скачать использовавшиеся при написании статьи.","type":"unordered-list-item","key":"8ibds"},{"data":{},"depth":0,"entityRanges":[{"key":4,"length":17,"offset":67},{"key":5,"length":9,"offset":180}],"inlineStyleRanges":[],"text":"Прежде чем задавать вопрос в комментариях, не забудьте заглянуть в предыдущие статьи, возможно там на него уже давался ответ. Исходный код готового проекта традиционно можно найти на GitHub.","type":"unstyled","key":"5qo96"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"С чего начать?","type":"header-three","key":"i7u9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Начать стоит с главного управляющего класса, который в нашем проекте находится выше остальных по уровню абстракции. Вообще отличный совет — в начале работы всегда пишите код вида if (getKeyPressed()) doSomething(), так вы быстро определите фронт работ.","type":"unstyled","key":"6f7h8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"975ht"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public static void main(String[] args) {\n initFields();\n\n while(!endOfGame){\n input();\n logic();\n\n graphicsModule.draw(gameField);\n graphicsModule.sync(FPS);\n }\n\n graphicsModule.destroy();\n}","type":"unstyled","key":"l4d9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"aemgr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это наш main(). Он ничем принципиально не отличается от тех, что мы писали в предыдущих статьях — мы всё так же инициализируем поля и, пока игра не закончится, осуществляем по очереди: ввод пользовательских данных (input()), основные игровые действия (logic()) и вызов метода отрисовки у графического модуля (graphicsModule.draw()), в который передаём текущее игровое поле (gameField). Из нового разве что метод sync — метод, который должен будет гарантировать нам определённую частоту выполнения итераций. С его помощью мы сможем задать скорость падения фигуры в клетках-в-секунду.","type":"unstyled","key":"4ocj4"},{"data":{},"depth":0,"entityRanges":[{"key":6,"length":9,"offset":222}],"inlineStyleRanges":[],"text":"Вы могли заметить, что в коде использована константа FPS. Все константы удобно определять в классе с public static final полями. Полный список констант, который нам потребуется в ходе разработки, можно посмотреть в классе Constants на GitHub.","type":"unstyled","key":"ejbtt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Оставим пока инициализацию полей на потом (мы же ещё не знаем, какие нам вообще понадобятся поля). Разберёмся сначала с input() и logic().","type":"unstyled","key":"14te2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Получение данных от пользователя","type":"header-three","key":"c8mtu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Код, честно говоря, достаточно капитанский:","type":"unstyled","key":"cs8bk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"62snk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"private static void input(){\n /// Обновляем данные модуля ввода\n keyboardModule.update();\n\n /// Считываем из модуля ввода направление для сдвига падающей фигурки\n shiftDirection = keyboardModule.getShiftDirection();\n\n /// Считываем из модуля ввода, хочет ли пользователь повернуть фигурку\n isRotateRequested = keyboardModule.wasRotateRequested();\n\n /// Считываем из модуля ввода, хочет ли пользователь \"уронить\" фигурку вниз\n isBoostRequested = keyboardModule.wasBoostRequested();\n\n /// Если был нажат ESC или \"крестик\" окна, завершаем игру\n endOfGame = endOfGame || keyboardModule.wasEscPressed() || graphicsModule.isCloseRequested();","type":"unstyled","key":"dvkuk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"4j21b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Все данные от ввода мы просто сохраняем в соответствующие поля, действия на основе них будет выполнять метод logic().","type":"unstyled","key":"do5ue"},{"data":{},"depth":0,"entityRanges":[{"key":7,"length":7,"offset":395}],"inlineStyleRanges":[],"text":"Теперь уже потихоньку становится понятно, что нам необходимо. Во-первых, нам нужны клавиатурный и графический модули. Во-вторых, нужно как-то хранить направление, которое игрок выбрал для сдвига. Вторая задача решается просто — создадим enum с тремя состояниями: AWAITING, LEFT, RIGHT. Зачем нужен AWAITING? Чтобы хранить информацию о том, что сдвиг не требуется (использования в программе null следует всеми силами избегать). Перейдём к интерфейсам.","type":"unstyled","key":"36t1r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интерфейсы для клавиатурного и графического модулей","type":"header-three","key":"adlj2"},{"data":{},"depth":0,"entityRanges":[{"key":8,"length":5,"offset":303}],"inlineStyleRanges":[],"text":"Так как многим не нравится, что я пишу эти модули на LWJGL, я решил в статье уделить время только интерфейсам этих классов. Каждый может написать их с помощью той GUI-библиотеки, которая ему нравится (или вообще сделать консольный вариант). Я же по старинке реализовал их на LWJGL, код можно посмотреть здесь в папках graphics/lwjglmodule и keyboard/lwjglmodule.","type":"unstyled","key":"f2i2j"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интерфейсы же, после добавления в них всех упомянутых выше методов, будут выглядеть следующим образом:","type":"unstyled","key":"4s9g4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"dlmvs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public interface GraphicsModule {\n\n /**\n * Отрисовывает переданное игровое поле\n *\n * @param field Игровое поле, которое необходимо отрисовать\n */\n void draw(GameField field);\n\n /**\n * @return Возвращает true, если в окне нажат \"крестик\"\n */\n boolean isCloseRequested();\n\n /**\n * Заключительные действия, на случай, если модулю нужно подчистить за собой.\n */\n void destroy();\n\n /**\n * Заставляет программу немного поспать, если последний раз метод вызывался\n * менее чем 1/fps секунд назад\n */\n void sync(int fps);\n}","type":"unstyled","key":"em7sg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public interface KeyboardHandleModule {\n\n /**\n * Считывание последних данных из стека событий, если модулю это необходимо\n */\n void update();\n\n /**\n * @return Возвращает информацию о том, был ли нажат ESCAPE за последнюю итерацию\n */\n boolean wasEscPressed();\n\n /**\n * @return Возвращает направление, в котором пользователь хочет сдвинуть фигуру.\n * Если пользователь не пытался сдвинуть фигуру, возвращает ShiftDirection.AWAITING.\n */\n ShiftDirection getShiftDirection();\n\n /**\n * @return Возвращает true, если пользователь хочет повернуть фигуру.\n */\n boolean wasRotateRequested();\n\n /**\n * @return Возвращает true, если пользователь хочет ускорить падение фигуры.\n */\n boolean wasBoostRequested();\n}","type":"unstyled","key":"bd220"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"18vvk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Отлично, мы получили от пользователя данные. Что дальше?","type":"header-three","key":"u7u9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А дальше мы должны эти данные обработать и что-то сделать с игровым полем. Если пользователь сказал сдвинуть фигуру куда-то, то передаём полю, что нужно сдвинуть фигуру в таком-то направлении. Если пользователь сказал, что нужно фигуру повернуть, поворачиваем, и так далее. Кроме этого нельзя забывать, что 1 раз в FRAMES_PER_MOVE (вы же открывали файл с константами?) итераций нам необходимо сдвигать падающую фигурку вниз.","type":"unstyled","key":"brnk7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"272tg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"private static void logic(){\n if(shiftDirection != ShiftDirection.AWAITING){ // Если есть запрос на сдвиг фигуры\n\n /* Пробуем сдвинуть */\n gameField.tryShiftFigure(shiftDirection);\n\n /* Ожидаем нового запроса */\n shiftDirection = ShiftDirection.AWAITING;\n }\n\n if(isRotateRequested){ // Если есть запрос на поворот фигуры\n\n /* Пробуем повернуть */\n gameField.tryRotateFigure();\n\n /* Ожидаем нового запроса */\n isRotateRequested = false;\n }\n\n /* Падение фигуры вниз происходит если loopNumber % FRAMES_PER_MOVE == 0\n * Т.е. 1 раз за FRAMES_PER_MOVE итераций.\n */\n if( (loopNumber % (FRAMES_PER_MOVE / (isBoostRequested ? BOOST_MULTIPLIER : 1)) ) == 0) gameField.letFallDown();\n\n /* Увеличение номера итерации (по модулю FPM)*/\n loopNumber = (loopNumber+1)% (FRAMES_PER_MOVE);","type":"unstyled","key":"emtvm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сюда же добавим проверку на переполнение поля (в Тетрисе игра завершается, когда фигурам некуда падать):","type":"unstyled","key":"7c6j0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/* Если поле переполнено, игра закончена */\n endOfGame = endOfGame || gameField.isOverfilled();\n }","type":"unstyled","key":"38aqp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"7438q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Так, а теперь мы напишем класс для того магического gameField, в который мы всё это передаём, да?","type":"header-three","key":"f9229"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Не совсем. Сначала мы пропишем поля класса Main и метод initFields(), чтобы совсем с ним закончить. Вот все поля, которые мы использовали:","type":"unstyled","key":"2633t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"cd5qv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/** Флаг для завершения основного цикла программы */\n private static boolean endOfGame;\n\n /** Графический модуль игры*/\n private static GraphicsModule graphicsModule;\n\n /** \"Клавиатурный\" модуль игры, т.е. модуль для чтения запросов с клавиатуры*/\n private static KeyboardHandleModule keyboardModule;\n\n /** Игровое поле. См. документацию GameField */\n private static GameField gameField;\n\n /** Направление для сдвига, полученное за последнюю итерацию */\n private static ShiftDirection shiftDirection;\n\n /** Был ли за последнюю итерацию запрошен поворот фигуры */\n private static boolean isRotateRequested;\n\n /** Было ли за последнюю итерацию запрошено ускорение падения*/\n private static boolean isBoostRequested;\n\n /** Номер игровой итерации по модулю FRAMES_PER_MOVE.\n * Падение фигуры вниз происходит если loopNumber % FRAMES_PER_MOVE == 0\n * Т.е. 1 раз за FRAMES_PER_MOVE итераций.\n */\n private static int loopNumber;","type":"unstyled","key":"do08k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А инициализировать мы их будем так:","type":"unstyled","key":"c95fa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"private static void initFields() {\n loopNumber = 0;\n endOfGame = false;\n shiftDirection = ShiftDirection.AWAITING;\n isRotateRequested = false;\n graphicsModule = new LwjglGraphicsModule();\n keyboardModule = new LwjglKeyboardHandleModule();\n gameField = new GameField();\n}","type":"unstyled","key":"6s99u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"ag2eq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если вы решили не использовать LWJGL и написали свои классы, реализующие GraphicsModule и KeyboardHandleModule, то здесь нужно указать их конструкторы вместо, соответственно new LwjglGraphicsModule() и new LwjglKeyboardHandleModule().","type":"unstyled","key":"en9j0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А вот теперь мы переходим к классу, который отвечает за хранение информации об игровом поле и её обновление.","type":"unstyled","key":"98nao"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Класс GameField","type":"header-three","key":"9fpsn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Этот класс должен, во-первых, хранить информацию о поле и о падающей фигуре, а во-вторых, содержать методы для их обновления, и получения о них информации — кроме тех, которые мы уже использовали, необходимо написать метод, возвращающий цвет ячейки по координатам, чтобы графический модуль мог отрисовать поле.","type":"unstyled","key":"1e29a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Начнём по порядку.","type":"unstyled","key":"dspae"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Хранить информацию о поле…","type":"header-three","key":"1uctr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/** Цвета ячеек поля. Для пустых ячеек используется константа EMPTINESS_COLOR */\n private TpReadableColor[][] theField;\n\n /** Количество непустых ячеек строки.\n * Можно было бы получать динамически из theField, но это дольше.\n */\n private int[] countFilledCellsInLine;","type":"unstyled","key":"4e7s5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"…и о падающей фигуре","type":"header-three","key":"8qmld"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/** Информация о падающей в данный момент фигуре */\nprivate Figure figure;","type":"unstyled","key":"d8ise"},{"data":{},"depth":0,"entityRanges":[{"key":9,"length":3,"offset":219}],"inlineStyleRanges":[],"text":"TpReadableColor — простой enum, содержащий элементы с говорящими названиями (RED, ORANGE и т.п.) и метод, позволяющий получить случайным образом один из этих элементов. Ничего особенного в нём нет, код можно посмотреть тут.","type":"unstyled","key":"69bnm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это все поля, которые нам понадобятся. Как известно, поля любят быть инициализированными.\nСделать это следует в конструкторе.","type":"unstyled","key":"addta"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Конструктор и инициализация полей","type":"header-three","key":"8uv9u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public GameField(){\n spawnNewFigure();\n\n theField = new TpReadableColor[COUNT_CELLS_X][COUNT_CELLS_Y+OFFSET_TOP];\n countFilledCellsInLine = new int[COUNT_CELLS_Y+OFFSET_TOP];","type":"unstyled","key":"f4ga0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"«Что это за OFFSET_TOP?» — спросите вы. OFFSET_TOP это количество неотображаемых ячеек сверху, в которых создаются падающие фигуры. Если фигуре не сможет «выпасть» из этого пространства, и хоть одна ячеек theField выше уровня COUNT_CELLS_Y будет заполнена, это будет обозначать, что поле переполнено и пользователь проиграл, поэтому OFFSET_TOP должен быть строго больше нуля.","type":"unstyled","key":"8bek"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Далее в конструкторе стоит заполнить массив theField значениями константы EMPTINESS_COLOR , а countFilledCellsInLine — нулями (второе в Java не требуется, при инициализации массива все int‘ы равны 0). Или можно создать несколько слоёв уже заполненных ячейкам — на GitHub вы можете увидеть реализацию именно второго варианта.","type":"unstyled","key":"edi2g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А что это там за spawnNewFigure()? Почему инициализация фигуры вынесена в отдельный метод?","type":"header-three","key":"cnd9i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вы правильно догадались, spawnNewFigure() действительно инициализирует поле figure. А в отдельный метод это вынесено, потому что нам придётся делать инициализацию каждый раз, когда будет создаваться новая фигура.","type":"unstyled","key":"fl2ml"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"f3eep"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/**\n * Создаёт новую фигуру в невидимой зоне\n * X-координата для генерации не должна быть ближе к правому краю,\n * чем максимальная ширина фигуры (MAX_FIGURE_WIDTH), чтобы влезть в экран\n */\n private void spawnNewFigure(){\n int randomX = new Random().nextInt(COUNT_CELLS_X - MAX_FIGURE_WIDTH);\n\n this.figure = new Figure(new Coord(randomX, COUNT_CELLS_Y + OFFSET_TOP - 1));\n }","type":"unstyled","key":"lmuk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"e3j3l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"На этом с хранением данных мы закончили. Переходим к методам, которые отдают информацию о поле другим классам.","type":"unstyled","key":"3cnfl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Методы, передающие информацию об игровом поле","type":"header-three","key":"bu8cb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Таких метода всего два. Первый возвращает цвет ячейки (для графического модуля):","type":"unstyled","key":"4evl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"9smad"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public TpReadableColor getColor(int x, int y) {\n return theField[x][y];\n}","type":"unstyled","key":"fd622"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А второй сообщает, переполнено ли поле (как это происходит, мы разобрали выше):","type":"unstyled","key":"13qmj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public boolean isOverfilled(){\n for(int i = 0; i < OFFSET_TOP; i++){\n if(countFilledCellsInLine[COUNT_CELLS_Y+i] != 0) return true;\n }\n\n return false;\n}","type":"unstyled","key":"ascrs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Методы, обновляющие фигуру и игровое поле","type":"header-three","key":"fukno"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Начнём реализовывать методы, которые мы вызывали из Main.logic().","type":"unstyled","key":"37ti2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сдвиг фигуры","type":"header-three","key":"9m37k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":98,"style":"ITALIC"}],"text":"За это отвечает метод tryShiftFigure(). В комментариях к его вызову из Main было сказано, что он «пробует сдвинуть фигуру». Почему пробует? Потому что если фигура находится вплотную к стене, а пользователь пытается её сдвинуть в направлении этой стены, никакого сдвига в реальности происходить не должно. Так же нельзя сдвинуть фигуру в статические ячейки на поле.","type":"unstyled","key":"bav9m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"th4d"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public void tryShiftFigure(ShiftDirection shiftDirection) {\n Coord[] shiftedCoords = figure.getShiftedCoords(shiftDirection);\n\n boolean canShift = true;\n\n for(Coord coord: shiftedCoords) {\n if((coord.y<0 || coord.y>=COUNT_CELLS_Y+OFFSET_TOP)\n ||(coord.x<0 || coord.x>=COUNT_CELLS_X)\n || ! isEmpty(coord.x, coord.y)){\n canShift = false;\n }\n }\n\n if(canShift){\n figure.shift(shiftDirection);\n }\n}","type":"unstyled","key":"evplf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"9afvf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Что мы сделали в этом методе? Мы запросили у фигуры ячейки, которые бы она заняла в случае сдвига. А затем для каждой из этих ячеек мы проверяем, не выходит ли она за пределы поля, и не находится ли по её координатам в сетке статичный блок. Если хоть одна ячейка фигуры выходит за пределы или пытается встать на место блока — сдвига не происходит. Coord здесь — класс-оболочка с двумя публичными числовыми полями (x и y координаты).","type":"unstyled","key":"3ubs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Поворот фигуры","type":"header-three","key":"4rdbn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Логика аналогична сдвигу:","type":"unstyled","key":"cblr9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Coord[] rotatedCoords = figure.getRotatedCoords();\n\n boolean canRotate = true;\n\n for(Coord coord: rotatedCoords) {\n if((coord.y<0 || coord.y>=COUNT_CELLS_Y+OFFSET_TOP)\n ||(coord.x<0 || coord.x>=COUNT_CELLS_X)\n ||! isEmpty(coord.x, coord.y)){\n canRotate = false;\n }\n }\n\n if(canRotate){\n figure.rotate();\n }","type":"unstyled","key":"62k7l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Падение фигуры","type":"header-three","key":"4016t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сначала код в точности повторяет предыдущие два метода:","type":"unstyled","key":"egp5n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public void letFallDown() {\n Coord[] fallenCoords = figure.getFallenCoords();\n\n boolean canFall = true;\n\n for(Coord coord: fallenCoords) {\n if((coord.y<0 || coord.y>=COUNT_CELLS_Y+OFFSET_TOP)\n ||(coord.x<0 || coord.x>=COUNT_CELLS_X)\n ||! isEmpty(coord.x, coord.y)){\n canFall = false;\n }\n }\n\n if(canFall) {\n figure.fall();","type":"unstyled","key":"ebbf0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Однако теперь, в случае, если фигура дальше падать не может, нам необходимо перенести её ячейки («кубики») в theField, т.е. в разряд статичных блоков, после чего создать новую фигуру:","type":"unstyled","key":"9be49"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"} else {\n Coord[] figureCoords = figure.getCoords();\n\n /* Флаг, говорящий о том, что после будет необходимо сместить линии вниз\n * (т.е. какая-то линия была уничтожена)\n */\n boolean haveToShiftLinesDown = false;\n\n for(Coord coord: figureCoords) {\n theField[coord.x][coord.y] = figure.getColor();\n\n /* Увеличиваем информацию о количестве статичных блоков в линии*/\n countFilledCellsInLine[coord.y]++;\n\n /* Проверяем, полностью ли заполнена строка Y\n * Если заполнена полностью, устанавливаем haveToShiftLinesDown в true\n */\n haveToShiftLinesDown = tryDestroyLine(coord.y) || haveToShiftLinesDown;\n }\n\n /* Если это необходимо, смещаем линии на образовавшееся пустое место */\n if(haveToShiftLinesDown) shiftLinesDown();\n\n /* Создаём новую фигуру взамен той, которую мы перенесли*/\n spawnNewFigure();\n}","type":"unstyled","key":"a32d7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Так как в результате переноса ячеек какая-то линия может заполниться полностью, после каждого добавления ячейки мы проверяем линию, в которую мы её добавили, на полноту:","type":"unstyled","key":"1kse6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"private boolean tryDestroyLine(int y) {\n if(countFilledCellsInLine[y] < COUNT_CELLS_X){\n return false;\n }\n\n for(int x = 0; x < COUNT_CELLS_X; x++){\n theField[x][y] = EMPTINESS_COLOR;\n }\n\n /* Не забываем обновить мета-информацию! */\n countFilledCellsInLine[y] = 0;\n\n return true;\n}","type":"unstyled","key":"1fs01"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Этот метод возвращает истину, если линию удалось уничтожить. После добавления всех кирпичиков фигуры в сетку (и удаления всех заполненных линий), мы, при необходимости, запускаем метод, который сдвигает на место пустых линий непустые:","type":"unstyled","key":"1gbbu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"private void shiftLinesDown() {\n\n /* Номер обнаруженной пустой линии (-1, если не обнаружена) */\n int fallTo = -1;\n\n /* Проверяем линии снизу вверх*/\n for(int y = 0; y < COUNT_CELLS_Y; y++){\n if(fallTo == -1){ //Если пустот ещё не обнаружено\n if(countFilledCellsInLine[y] == 0) fallTo = y; //...пытаемся обнаружить (._.)\n } else { //А если обнаружено\n if(countFilledCellsInLine[y] != 0){ // И текущую линию есть смысл сдвигать...\n\n /* Сдвигаем... */\n for(int x = 0; x < COUNT_CELLS_X; x++){\n theField[x][fallTo] = theField[x][y];\n theField[x][y] = EMPTINESS_COLOR;\n }\n\n /* Не забываем обновить мета-информацию*/\n countFilledCellsInLine[fallTo] = countFilledCellsInLine[y];\n countFilledCellsInLine[y] = 0;\n\n /*\n * В любом случае линия сверху от предыдущей пустоты пустая.\n * Если раньше она не была пустой, то сейчас мы её сместили вниз.\n * Если раньше она была пустой, то и сейчас пустая -- мы её ещё не заполняли.\n */\n fallTo++;\n }\n }\n }\n}","type":"unstyled","key":"89ahj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Теперь GameField реализован почти полностью — за исключением геттера для фигуры. Её ведь графическому модулю тоже придётся отрисовывать:","type":"unstyled","key":"d4756"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public Figure getFigure() {\n return figure;\n}","type":"unstyled","key":"eli3t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Теперь нам нужно написать алгоритмы, по которым фигура определяет свои координаты в разных состояниях. Да и вообще весь класс фигуры.","type":"unstyled","key":"bjn23"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Класс фигуры","type":"header-three","key":"cn21f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализовать это всё я предлагаю следующим образом — хранить для фигуры (1) «мнимую» координату, такую, что все реальные блоки находятся ниже и правее неё, (2) состояние поворота (их всего 4, после 4-х поворотов фигура всегда возвращается в начальное положение) и (3) маску, которая по первым двум параметрам будет определять положение реальных блоков:","type":"unstyled","key":"49mn6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/**\n * Мнимая координата фигуры. По этой координате\n * через маску генерируются координаты реальных\n * блоков фигуры.\n */\n private Coord metaPointCoords;\n\n /**\n * Текущее состояние поворота фигуры.\n */\n private RotationMode currentRotation;\n\n /**\n * Форма фигуры.\n */\n private FigureForm form;","type":"unstyled","key":"cb670"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Rotation мод здесь будет выглядеть таким образом:","type":"unstyled","key":"3stet"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public enum RotationMode {\n /** Начальное положение */\n NORMAL(0),\n\n /** Положение, соответствующее повороту против часовой стрелки*/\n FLIP_CCW(1),\n\n /** Положение, соответствующее зеркальному отражению*/\n INVERT(2),\n\n /** Положение, соответствующее повороту по часовой стрелке (или трём поворотам против)*/\n FLIP_CW(3);\n\n\n\n /** Количество поворотов против часовой стрелки, необходимое для принятия положения*/\n private int number;\n\n /**\n * Конструктор.\n *\n * @param number Количество поворотов против часовой стрелки, необходимое для принятия положения\n */\n RotationMode(int number){\n this.number = number;\n }\n\n /** Хранит объекты enum'а. Индекс в массиве соответствует полю number.\n * Для более удобной работы getNextRotationForm().\n */\n private static RotationMode[] rotationByNumber = {NORMAL, FLIP_CCW, INVERT, FLIP_CW};\n\n /**\n * Возвращает положение, образованое в результате поворота по часовой стрелке\n * из положения perviousRotation\n *\n * @param perviousRotation Положение из которого был совершён поворот\n * @return Положение, образованное в результате поворота\n */\n public static RotationMode getNextRotationFrom(RotationMode perviousRotation) {\n int newRotationIndex = (perviousRotation.number + 1) % rotationByNumber.length;\n return rotationByNumber[newRotationIndex];\n }\n}","type":"unstyled","key":"cs2sa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Соответственно, от самого класса Figure нам нужен только конструктор, инициализирующий поля:","type":"unstyled","key":"4mt69"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/**\n * Конструктор.\n * Состояние поворота по умолчанию: RotationMode.NORMAL\n * Форма задаётся случайная.\n *\n * @param metaPointCoords Мнимая координата фигуры. См. документацию одноимённого поля\n */\n public Figure(Coord metaPointCoords){\n this(metaPointCoords, RotationMode.NORMAL, FigureForm.getRandomForm());\n }\n\n public Figure(Coord metaPointCoords, RotationMode rotation, FigureForm form){\n this.metaPointCoords = metaPointCoords;\n this.currentRotation = rotation;\n this.form = form;\n }\n }","type":"unstyled","key":"d3vio"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"И методы, которыми мы пользовались в GameField следующего вида:","type":"unstyled","key":"5uem8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/**\n * @return Координаты реальных ячеек фигуры в текущем состоянии\n */\n public Coord[] getCoords(){\n return form.getMask().generateFigure(metaPointCoords, currentRotation);\n }\n\n /**\n * @return Координаты ячеек фигуры, как если бы\n * она была повёрнута проти часовой стрелки от текущего положения\n */\n public Coord[] getRotatedCoords(){\n return form.getMask().generateFigure(metaPointCoords, RotationMode.getNextRotationFrom(currentRotation));\n }\n\n /**\n * Поворачивает фигуру против часовой стрелки\n */\n public void rotate(){\n this.currentRotation = RotationMode.getNextRotationFrom(currentRotation);\n }\n\n /**\n * @param direction Направление сдвига\n * @return Координаты ячеек фигуры, как если бы\n * она была сдвинута в указано направлении\n */\n public Coord[] getShiftedCoords(ShiftDirection direction){\n Coord newFirstCell = null;\n\n switch (direction){\n case LEFT:\n newFirstCell = new Coord(metaPointCoords.x - 1, metaPointCoords.y);\n break;\n case RIGHT:\n newFirstCell = new Coord(metaPointCoords.x + 1, metaPointCoords.y);\n break;\n default:\n ErrorCatcher.wrongParameter(\"direction (for getShiftedCoords)\", \"Figure\");\n }\n\n return form.getMask().generateFigure(newFirstCell, currentRotation);\n }\n\n /**\n * Меняет мнимую X-координату фигуры\n * для сдвига в указаном направлении\n *\n * @param direction Направление сдвига\n */\n public void shift(ShiftDirection direction){\n switch (direction){\n case LEFT:\n metaPointCoords.x--;\n break;\n case RIGHT:\n metaPointCoords.x++;\n break;\n default:\n ErrorCatcher.wrongParameter(\"direction (for shift)\", \"Figure\");\n }\n }\n\n /**\n * @return Координаты ячеек фигуры, как если бы\n * она была сдвинута вниз на одну ячейку\n */\n public Coord[] getFallenCoords(){\n Coord newFirstCell = new Coord(metaPointCoords.x, metaPointCoords.y - 1);\n\n return form.getMask().generateFigure(newFirstCell, currentRotation);\n }\n\n /**\n * Меняет мнимую Y-координаты фигуры\n * для сдвига на одну ячейку вниз\n */\n public void fall(){\n metaPointCoords.y--;\n }","type":"unstyled","key":"2k1e2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вдобавок, у фигуры должен быть цвет, чтобы графический модуль мог её отобразить. В тетрисе каждой фигуре соответствует свой цвет, поэтому цвет мы будем запрашивать у формы:","type":"unstyled","key":"dctm1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public TpReadableColor getColor() {\n return form.getColor();\n}","type":"unstyled","key":"9e7mc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Форма фигуры и маски координат","type":"header-three","key":"3clhk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Чтобы не занимать лишнее место, здесь я приведу реализацию только для двух форм: I-образной и J-образной. Код для остальных фигур принципиально не отличается и выложен на GitHub.","type":"unstyled","key":"ao8l2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Храним для каждой фигуры маску координат (которая определяет, насколько каждый реальный блок должен отстоять от «мнимой» координаты фигуры) и цвет:","type":"unstyled","key":"45ep5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public enum FigureForm {\n\n I_FORM (CoordMask.I_FORM, TpReadableColor.BLUE),\n J_FORM (CoordMask.J_FORM, TpReadableColor.ORANGE);\n\n/** Маска координат (задаёт геометрическую форму) */\n private CoordMask mask;\n\n /** Цвет, характерный для этой формы */\n private TpReadableColor color;\n\n FigureForm(CoordMask mask, TpReadableColor color){\n this.mask = mask;\n this.color = color;\n }","type":"unstyled","key":"44let"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализуем методы, которые использовали выше:","type":"unstyled","key":"94e9j"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/**\n * Массив со всеми объектами этого enum'а (для удобной реализации getRandomForm() )\n */\n private static final FigureForm[] formByNumber = {I_FORM, J_FORM, L_FORM, O_FORM, S_FORM, Z_FORM, T_FORM,};\n\n /**\n * @return Маска координат данной формы\n */\n public CoordMask getMask(){\n return this.mask;\n }\n\n /**\n * @return Цвет, специфичный для этой формы\n */\n public TpReadableColor getColor(){\n return this.color;\n }\n\n /**\n * @return Случайный объект этого enum'а, т.е. случайная форма\n */\n public static FigureForm getRandomForm() {\n int formNumber = new Random().nextInt(formByNumber.length);\n return formByNumber[formNumber];\n }","type":"unstyled","key":"gvut"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Ну а сами маски координат я предлагаю просто захардкодить следующим образом:","type":"unstyled","key":"3j235"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"/**\n * Каждая маска -- шаблон, который по мнимой координате фигуры и\n * состоянию её поворота возвращает 4 координаты реальных блоков\n * фигуры, которые должны отображаться.\n * Т.е. маска задаёт геометрическую форму фигуры.\n *\n * @author DoKel\n * @version 1.0\n */\npublic enum CoordMask {\n I_FORM(\n new GenerationDelegate() {\n @Override\n public Coord[] generateFigure(Coord initialCoord, RotationMode rotation) {\n Coord[] ret = new Coord[4];\n\n switch (rotation){\n case NORMAL:\n case INVERT:\n ret[0] = initialCoord;\n ret[1] = new Coord(initialCoord.x , initialCoord.y - 1);\n ret[2] = new Coord(initialCoord.x, initialCoord.y - 2);\n ret[3] = new Coord(initialCoord.x, initialCoord.y - 3);\n break;\n case FLIP_CCW:\n case FLIP_CW:\n ret[0] = initialCoord;\n ret[1] = new Coord(initialCoord.x + 1, initialCoord.y);\n ret[2] = new Coord(initialCoord.x + 2, initialCoord.y);\n ret[3] = new Coord(initialCoord.x + 3, initialCoord.y);\n break;\n }\n\n return ret;\n }\n }\n ),\n J_FORM(\n new GenerationDelegate() {\n @Override\n public Coord[] generateFigure(Coord initialCoord, RotationMode rotation) {\n Coord[] ret = new Coord[4];\n\n switch (rotation){\n case NORMAL:\n ret[0] = new Coord(initialCoord.x + 1 , initialCoord.y);\n ret[1] = new Coord(initialCoord.x + 1, initialCoord.y - 1);\n ret[2] = new Coord(initialCoord.x + 1, initialCoord.y - 2);\n ret[3] = new Coord(initialCoord.x, initialCoord.y - 2);\n break;\n case INVERT:\n ret[0] = new Coord(initialCoord.x + 1 , initialCoord.y);\n ret[1] = initialCoord;\n ret[2] = new Coord(initialCoord.x, initialCoord.y - 1);\n ret[3] = new Coord(initialCoord.x, initialCoord.y - 2);\n break;\n case FLIP_CCW:\n ret[0] = initialCoord;\n ret[1] = new Coord(initialCoord.x + 1, initialCoord.y);\n ret[2] = new Coord(initialCoord.x + 2, initialCoord.y);\n ret[3] = new Coord(initialCoord.x + 2, initialCoord.y - 1);\n break;\n case FLIP_CW:\n ret[0] = initialCoord;\n ret[1] = new Coord(initialCoord.x, initialCoord.y - 1);\n ret[2] = new Coord(initialCoord.x + 1, initialCoord.y - 1);\n ret[3] = new Coord(initialCoord.x + 2, initialCoord.y - 1);\n break;\n }\n\n return ret;\n }\n }\n );\n\n/**\n * Делегат, содержащий метод,\n * который должен определять алгоритм для generateFigure()\n */\n private interface GenerationDelegate{\n\n /**\n * По мнимой координате фигуры и состоянию её поворота\n * возвращает 4 координаты реальных блоков фигуры, которые должны отображаться\n *\n * @param initialCoord Мнимая координата\n * @param rotation Состояние поворота\n * @return 4 реальные координаты\n */\n Coord[] generateFigure(Coord initialCoord, RotationMode rotation);\n }\n\n private GenerationDelegate forms;\n\n CoordMask(GenerationDelegate forms){\n this.forms = forms;\n }\n\n /**\n * По мнимой координате фигуры и состоянию её поворота\n * возвращает 4 координаты реальных блоков фигуры, которые должны отображаться.\n *\n * Запрос передаётся делегату, спецефичному для каждого объекта enum'а.\n *\n * @param initialCoord Мнимая координата\n * @param rotation Состояние поворота\n * @return 4 реальные координаты\n */\n public Coord[] generateFigure(Coord initialCoord, RotationMode rotation){\n return this.forms.generateFigure(initialCoord, rotation);\n }\n\n}","type":"unstyled","key":"b6rfh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Т.е. для каждого объекта enum‘а мы передаём с помощью импровизированных (других в Java нет) делегатов метод, в котором в зависимости от переданного состояния поворота возвращаем разные реальные координаты блоков. В общем-то, можно обойтись и без делегатов, если хранить в каждом элементе отсупы для каждого из режимов поворота.","type":"unstyled","key":"7r4vv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"cmnth"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":24,"offset":0,"style":"BOLD"}],"text":"Наслаждаемся результатом","type":"unstyled","key":"d1ooq"},{"data":{"image":{"id":"636f03a45d1bb103eee0996f"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"dtfi6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"stke"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"mTrhEyFjDUSi5JPmOmiS"}],"entityMap":{"0":{"data":{"href":"http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html","url":"http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"href":"https://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/mars2","url":"https://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/mars2"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"href":"https://github.com/DoKel/tprogersTetris/tree/master/lib","url":"https://github.com/DoKel/tprogersTetris/tree/master/lib"},"mutability":"MUTABLE","type":"LINK"},"3":{"data":{"href":"https://github.com/DoKel/tprogersTetris/tree/master/src/ru/tproger/graphics/lwjglmodule","url":"https://github.com/DoKel/tprogersTetris/tree/master/src/ru/tproger/graphics/lwjglmodule"},"mutability":"MUTABLE","type":"LINK"},"4":{"data":{"href":"https://tproger.ru/articles/15-mins-for-2048/","url":"https://tproger.ru/articles/15-mins-for-2048/"},"mutability":"MUTABLE","type":"LINK"},"5":{"data":{"href":"https://github.com/DoKel/tprogersTetris/","url":"https://github.com/DoKel/tprogersTetris/"},"mutability":"MUTABLE","type":"LINK"},"6":{"data":{"href":"https://github.com/DoKel/tprogersTetris/blob/master/src/ru/tproger/main/Constants.java","url":"https://github.com/DoKel/tprogersTetris/blob/master/src/ru/tproger/main/Constants.java"},"mutability":"MUTABLE","type":"LINK"},"7":{"data":{"href":"http://www.yegor256.com/2014/05/13/why-null-is-bad.html","url":"http://www.yegor256.com/2014/05/13/why-null-is-bad.html"},"mutability":"MUTABLE","type":"LINK"},"8":{"data":{"href":"https://github.com/DoKel/tprogersTetris/tree/master/src/ru/tproger/graphics/lwjglmodule","url":"https://github.com/DoKel/tprogersTetris/tree/master/src/ru/tproger/graphics/lwjglmodule"},"mutability":"MUTABLE","type":"LINK"},"9":{"data":{"href":"https://github.com/DoKel/tprogersTetris/blob/master/src/ru/tproger/graphics/TpReadableColor.java","url":"https://github.com/DoKel/tprogersTetris/blob/master/src/ru/tproger/graphics/TpReadableColor.java"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}