Как написать свою игру для телефона

Давно мечтаете сделать свое приложение, имеете интересные идеи, хотите заработать на создании качественной игры? Безусловно, практически каждый пользователь загорался таким желанием, но часто останавливают сомнения, страхи и неуверенность. Ведь как создать игру на Андроид с нуля самому, если навыки программирования слабо развиты, владение английским языком оставляет желать лучшего, а никаких специализированных программ под рукой нет? Попытаемся разобраться.

Уровень сложности создания Android-игр

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

Да, огромные приложения с 3D-графикой делаются популярными и богатыми компаниями, где работают настоящие титаны с превосходными навыками. Но не всегда такие игрушки добиваются популярности, тогда как даже простое и элементарное приложение, разработанное новичком, имеет все шансы завоевать любовь миллионов пользователей со всего мира.

Что же необходимо знать и уметь человеку, решившему внести свое изобретение в игровую сферу? Для начала, это иметь хотя бы минимальные знания в языке программирования, которые с легкостью можно получить на курсах информатики или с помощью специальных учебников. Оптимальный вариант – язык Java. В виде альтернативы вполне можно представить программные коды, способные заменить конкретные действия в игре, но тогда вы должны хорошо владеть английским языком.

Также развеем заблуждение о том, что для создания приложения необходимо полностью знать Photoshop, иметь дизайнерский вкус и отлично рисовать. Но не стоит путать, например, новое приложение для общения с полноценной игрой. Если вы решили создать первое – там главное только текст и клавиши управления, но если настоящую игру – без художественных элементов не обойтись. И фишка в чем: эти элементы находятся в конструкторе. То есть, собственноручно рисовать вам придется очень редко.

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

Теперь подводим небольшие итоги. Если вы решили создать свою игру, то для этого требуется:

• Идея, образное представление, о чем будет игра, знание ее основного сюжета;
• Минимальное владение языком Java, ведь полностью без программирования (без нужных знаний) не обойтись;
• Установленная на компьютере программа для создания продукта;
• Свободное время, внимательность и желание трудиться.

Какую игру лучше всего создать

Четких ограничений нет, выбор в конструкторах обычно предоставляется обширный: квест, карточная игра, догонялки, стрелялки, экшн. Обилием жанров больше всего славится приложение Construct 2.

Самым лучшим вариантом для новичка, пожалуй, станет платформер. Бродилки по незамысловатому лабиринту или легкая драка со злодеем – типичный, но довольно неплохой сюжет для начала. И все это вполне реально воссоздать, используя бесплатный и удобный конструктор.

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

Самое сложное направление для создания, это, конечно, экшн-игры, где присутствует детальный проработанный мир, обычно сделанный в 3D-формате, несколько главных персонажей, длительный сюжет и множество уровней. На примере рассмотрим известное приложение Modern Combat. Конечно, для такой мощной игрушки требуются десятки специалистов, хорошие вложенные деньги и месяца работы. Но это не значит, что пользователь сам не сможет создать 3D-игру. Нужны только хорошие умения и навыки, поэтому этот жанр следует оставить на потом.

Как создать игру на Андроид с нуля без навыков программирования

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

Обратите внимание! Мы советуем загружать приложения только с проверенных сайтов и перед установкой тщательно проверять их антивирусом. В противном случае есть риск занести вредоносные файлы в свою операционную систему.

Construct 2 — простая платформа для 2D приложений

Лучшее приложение в своем роде, которое занимает лидирующие позиции. Главное преимущество – это возможность создавать игры практически на все платформы, в том числе и на Android. Поддерживается и анимационный формат HTML5, с помощью которого созданные творения будут доступны для игры онлайн во всех браузерах, что немаловажно, ведь такие игрушки гораздо проще в функционировании.

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

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

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

К сожалению, существует и минус: в бесплатной версии можно экспортировать творения в браузеры, а оттуда открывать их на совершенно любой платформе, но бесплатно создать игру только для Андроид не получится. Для этого придется вкладывать деньги в платную версию, стоимость которой немного превышает 100 долларов. Зато потом возможности намного расширяются, игры без проблем можно делать чисто на Андроид или iOS, а с помощью установочных файлов открывать приложения на персональном компьютере.

Видео-инструкция как сделать игру на Андроид с помощью Construct 2 и Construct 3

Unity 3D — мощный движок для разработки 3D проектов

Если предыдущая программа позволяла создавать только 2D-игры, то Unity 3D уже выходит на новый уровень и предоставляет разработчикам все условия для создания отличного трехмерного проекта. Программа оснащена различными готовыми моделями, изображениями, скриптами и текстурами на любой вкус. Компиляция имеет высокую скорость, редактор, несмотря на свою многофункциональность, очень прост в использовании.

Благодаря ядру PhysX все действия персонажей проработаны до мелочей, выглядит созданная игра качественно и дорого, даже если в ней задействован простой сюжет, не отличающийся особой продолжительностью.

Единственное требование – это достаточно мощный компьютер, поддерживающий 3D-форматы и навык программирования среднего уровня, поскольку новичкам будет все же немного трудно разобраться.

Видео-инструкция по созданию игры с помощью Unity 3D за 45 минут

Game Maker — самый легкий вариант для новичка

Наиболее легкая программа из всех существующих, идеальная для неопытных и неуверенных в своих знаниях пользователей. Именно здесь можно обойтись и без программирования, и без языка Java.

Приложение предоставляет для свободного использования множество интересных персонажей, объектов, локаций, эффектов. Разработчику остается только перетаскивать нужные предметы на основной фон и выбирать взаимодействие.

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

Видео-мануал по программе Game Maker

Этапы создания игр

Делаем  простую игру

Под простой игрой подразумевается самый незамысловатый сюжет. На примере рассмотрим такую идею: человечку необходимо преодолеть препятствия, чтобы благополучно добраться до финиша. К тому же, по дороге желательно собирать монетки. Согласитесь, воспроизвести такую картинку с помощью Construct 2 довольно просто и интересно. Рассмотрим приблизительные ориентировочные действия:

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

Для пошаговых действий и подробной инструкции смотрите видео, которое прилагается к этому разделу.

Делаем карточную игру

Для такого жанра лучше всего использовать программу Unity 3D. Здесь же рассмотрим направления и шаги:

• Делаем основной фон для карт;
• Проектируем сами карты, то есть, инвентарь;
• Задаем взаимодействия;
• Определяем количество игроков;
• Переводим меню игры из 3D в 2D;
• Определяем конец игры.

Создаем РПГ-игру

Отличной программой для такого жанра является программа RMXP или тот же Unity3D, выпущенная японской компанией. Для создания подобной игры нужно время и внимательность, но ни с чем сложным вы не столкнетесь.

• Придумываем основную идею будущей Андроид игры;
• Пишем основной сценарий;
• Рисуем базовую карту и добавляем объекты;
• Создаем события.

Как создать онлайн-игру для Андроид

Отдельной схемы для создания именно онлайн игры не существует. Приложение данного типа делается с помощью вышеперечисленных программ, а куда публиковать свое творение – напрямую в Android и iOS, либо в браузеры – решать вам.

Обратите внимание! Создание игры без использования ПК стандартными методами невозможно. Большинство популярных программ ориентировано только на компьютеры.

Три 100% способа, чтобы заработать на своей игре

Первое – качественная и интересная игра. Как и в любом другом деле, для хороших продаж продукт должен заинтересовывать и отличаться своей изюминкой. Старайтесь избегать избитых сюжетов, тщательно продумывать каждую деталь приложения. Даже если игра небольшая и простая – сделайте ее максимально качественной и «дорогой».

Второе – не следует самому искать спонсоров. Если игра достойная, и вы хотите ее продать, для начала выставите продукт на специальные аукционы, типа gamebrokage. К сожалению, шанс, что игрой новичка сразу заинтересуются, невелик, но попробовать стоит. Разумеется, первые проекты лучше создавать для более узкого круга людей, узнавать мнение друзей, близких и т. д.

Третье – собственная реклама. Если вы уже пустили свою игру на просторы Интернета, то для популярности необходима хорошая постоянная реклама. Можете создать свой портал игр, публиковать соответствующие записи в социальных сетях. Словом, делать все, чтобы ее заметили.

Ответы на популярные вопросы

Вопрос: Если моя игра находится в Google Play, ее можно обновлять?
Обновление на Google Play будет доступно только тогда, когда вы сами его выпустите, поскольку являетесь разработчиком приложения.

Вопрос: Какая средняя стоимость игры, выпущенной пользователем-самоучкой со средним уровнем программирования?
Здесь все зависит от конкретных факторов: размер игры, ее графика, продолжительность, качество. Если говорить о мировом рынке, то около 100 долларов.

Вопрос: Можно ли 2D игру перевести в 3D?
Да, с помощью специальных программ это вполне возможно, но процедура непростая.

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

Как видим, создание игры на Андроид с нуля – довольно легкий и интересный процесс, справиться с которым самому не составит проблем. За получением помощи можете смело писать в комментарии. Успехов!

Время на прочтение
10 мин

Количество просмотров 137K

Этот туториал предназначен в первую очередь для новичков в разработке под андроид, но может быть будет полезен и более опытным разработчикам. Тут рассказано как создать простейшую 2D игру на анроиде без использования каких-либо игровых движков. Для этого я использовал Android Studio, но можно использовать любую другую соответствующее настроенную среду разработки.

Шаг 1. Придумываем идею игры
Для примера возьмём довольно простую идею:

Внизу экрана — космический корабль. Он может двигаться влево и вправо по нажатию соответствующих кнопок. Сверху вертикально вниз движутся астероиды. Они появляются по всей ширине экрана и двигаются с разной скоростью. Корабль должен уворачиваться от метеоритов как можно дольше. Если метеорит попадает в него — игра окончена.

Шаг 2. Создаём проект
В Android Studio в верхнем меню выбираем File → New → New Project.

Тут вводим название приложения, домен и путь. Нажимаем Next.

Тут можно ввести версию андроид. Также можно выбрать андроид часы и телевизор. Но я не уверен что наше приложение на всём этом будет работать. Так что лучше введите всё как на скриншоте. Нажимаем Next.

Тут обязательно выбираем Empty Activity. И жмём Next.

Тут оставляем всё как есть и жмём Finish. Итак проект создан. Переходим ко третьему шагу.

Шаг 3. Добавляем картинки

Скачиваем архив с картинками и распаковываем его.

Находим папку drawable и копируем туда картинки.

Позже они нам понадобятся.

Шаг 4. Создаём layout

Находим activity_main.xml, открываем вкладку Text и вставляем туда это:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.spaceavoider.spaceavoider.MainActivity">
    <LinearLayout
        android:id="@+id/gameLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:layout_weight="100"/>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <Button
            android:id="@+id/leftButton"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="50"
            android:text="Left" />
        <Button
            android:id="@+id/rightButton"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="50"
            android:text="Right" />
    </LinearLayout>
</LinearLayout>

На вкладке Design видно как наш layout будет выглядеть.

Сверху поле в котором будет сама игра, а снизу кнопки управления Left и Right. Про layout можно написать отдельную статью, и не одну. Я не буду на этом подробно останавливаться. Про это можно почитать тут.

Шаг 5. Редактируем MainActivity класс

В первую очередь в определение класса добавляем implements View.OnTouchListener. Определение класса теперь будет таким:

public class MainActivity extends AppCompatActivity implements View.OnTouchListener {

Добавим в класс нужные нам статические переменные (переменные класса):

public static boolean isLeftPressed = false; // нажата левая кнопка
public static boolean isRightPressed = false; // нажата правая кнопка

В процедуру protected void onCreate(Bundle savedInstanceState) {
добавляем строки:

GameView gameView = new GameView(this); // создаём gameView

LinearLayout gameLayout = (LinearLayout) findViewById(R.id.gameLayout); // находим gameLayout
gameLayout.addView(gameView); // и добавляем в него gameView

Button leftButton = (Button) findViewById(R.id.leftButton); // находим кнопки
Button rightButton = (Button) findViewById(R.id.rightButton);

leftButton.setOnTouchListener(this); // и добавляем этот класс как слушателя (при нажатии сработает onTouch)
rightButton.setOnTouchListener(this);

Классы LinearLayout, Button и т.д. подсвечены красным потому что ещё не добавлены в Import.
Чтобы добавить в Import и убрать красную подсветку нужно для каждого нажать Alt+Enter.
GameView будет подсвечено красным потому-что этого класса ещё нет. Мы создадим его позже.

Теперь добавляем процедуру:

public boolean onTouch(View button, MotionEvent motion) {
    switch(button.getId()) { // определяем какая кнопка
        case R.id.leftButton:
            switch (motion.getAction()) { // определяем нажата или отпущена
                case MotionEvent.ACTION_DOWN:
                    isLeftPressed = true;
                    break;
                case MotionEvent.ACTION_UP:
                    isLeftPressed = false;
                    break;
            }
            break;
        case R.id.rightButton:
            switch (motion.getAction()) { // определяем нажата или отпущена
                case MotionEvent.ACTION_DOWN:
                    isRightPressed = true;
                    break;
                case MotionEvent.ACTION_UP:
                    isRightPressed = false;
                    break;
            }
            break;
    }
    return true;
}

Если кто-то запутался ― вот так в результате должен выглядеть MainActivity класс:

package com.spaceavoider.spaceavoider;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
public class MainActivity extends AppCompatActivity implements View.OnTouchListener {
    public static boolean isLeftPressed = false; // нажата левая кнопка
    public static boolean isRightPressed = false; // нажата правая кнопка
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        GameView gameView = new GameView(this); // создаём gameView
        LinearLayout gameLayout = (LinearLayout) findViewById(R.id.gameLayout); // находим gameLayout
        gameLayout.addView(gameView); // и добавляем в него gameView
        Button leftButton = (Button) findViewById(R.id.leftButton); // находим кнопки
        Button rightButton = (Button) findViewById(R.id.rightButton);
        leftButton.setOnTouchListener(this); // и добавляем этот класс как слушателя (при нажатии сработает onTouch)
        rightButton.setOnTouchListener(this);
    }
    public boolean onTouch(View button, MotionEvent motion) {
        switch(button.getId()) { // определяем какая кнопка
            case R.id.leftButton:
                switch (motion.getAction()) { // определяем нажата или отпущена
                    case MotionEvent.ACTION_DOWN:
                        isLeftPressed = true;
                        break;
                    case MotionEvent.ACTION_UP:
                        isLeftPressed = false;
                        break;
                }
                break;
            case R.id.rightButton:
                switch (motion.getAction()) { // определяем нажата или отпущена
                    case MotionEvent.ACTION_DOWN:
                        isRightPressed = true;
                        break;
                    case MotionEvent.ACTION_UP:
                        isRightPressed = false;
                        break;
                }
                break;
        }
        return true;
    }
}

Итак, класс MainActivity готов! В нём инициирован ещё не созданный класс GameView. И когда нажата левая кнопка — статическая переменная isLeftPressed = true, а когда правая — isRightPressed = true. Это в общем то и всё что он делает.

Для начала сделаем чтобы на экране отображался космический корабль, и чтобы он двигался по нажатию управляющих кнопок. Астероиды оставим на потом.

Шаг 6. Создаём класс GameView

Теперь наконец-то создадим тот самый недостающий класс GameView. Итак приступим. В определение класса добавим extends SurfaceView implements Runnable. Мобильные устройства имею разные разрешения экрана. Это может быть старенький маленький телефон с разрешением 480×800, или большой планшет 1800×2560. Для того чтобы игра выглядела на всех устройствах одинаково я поделил экран на 20 частей по горизонтали и 28 по вертикали. Полученную единицу измерения я назвал юнит. Можно выбрать и другие числа. Главное чтобы отношение между ними примерно сохранялось, иначе изображение будет вытянутым или сжатым.

public static int maxX = 20; // размер по горизонтали
public static int maxY = 28; // размер по вертикали
public static float unitW = 0; // пикселей в юните по горизонтали
public static float unitH = 0; // пикселей в юните по вертикали

unitW и unitW мы вычислим позже. Также нам понадобятся и другие переменные:

private boolean firstTime = true;
private boolean gameRunning = true;
private Ship ship;
private Thread gameThread = null;
private Paint paint;
private Canvas canvas;
private SurfaceHolder surfaceHolder;

Конструктор будет таким:

public GameView(Context context) {
    super(context);
    //инициализируем обьекты для рисования
    surfaceHolder = getHolder();
    paint = new Paint();

    // инициализируем поток
    gameThread = new Thread(this);
    gameThread.start();
}

Метод run() будет содержать бесконечный цикл. В начале цикла выполняется метод update()
который будет вычислять новые координаты корабля. Потом метод draw() рисует корабль на экране. И в конце метод control() сделает паузу на 17 миллисекунд. Через 17 миллисекунд run() запустится снова. И так до пока переменная gameRunning == true. Вот эти методы:

@Override
public void run() {
    while (gameRunning) {
        update();
        draw();
        control();
    }
}

private void update() {
    if(!firstTime) {
        ship.update();
    }
}

private void draw() {
    if (surfaceHolder.getSurface().isValid()) {  //проверяем валидный ли surface

        if(firstTime){ // инициализация при первом запуске
            firstTime = false;
            unitW = surfaceHolder.getSurfaceFrame().width()/maxX; // вычисляем число пикселей в юните
            unitH = surfaceHolder.getSurfaceFrame().height()/maxY;

            ship = new Ship(getContext()); // добавляем корабль
        }

        canvas = surfaceHolder.lockCanvas(); // закрываем canvas
        canvas.drawColor(Color.BLACK); // заполняем фон чёрным

        ship.drow(paint, canvas); // рисуем корабль

        surfaceHolder.unlockCanvasAndPost(canvas); // открываем canvas
    }
}

private void control() { // пауза на 17 миллисекунд
    try {
        gameThread.sleep(17);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Обратите внимание на инициализацию при первом запуске. Там мы вычисляем количество пикселей в юните и добавляем корабль. Корабль мы ещё не создали. Но прежде мы создадим его родительский класс.

Шаг 7. Создаём класс SpaceBody

Он будет родительским для класса Ship (космический корабль) и Asteroid (астероид). В нём будут содержаться все переменные и методы общие для этих двух классов. Добавляем переменные:

protected float x; // координаты
protected float y;
protected float size; // размер
protected float speed; // скорость
protected int bitmapId; // id картинки
protected Bitmap bitmap; // картинка

и методы

void init(Context context) { // сжимаем картинку до нужных размеров
    Bitmap cBitmap = BitmapFactory.decodeResource(context.getResources(), bitmapId);
    bitmap = Bitmap.createScaledBitmap(
            cBitmap, (int)(size * GameView.unitW), (int)(size * GameView.unitH), false);
    cBitmap.recycle();
}

void update(){ // тут будут вычисляться новые координаты
}

void drow(Paint paint, Canvas canvas){ // рисуем картинку
    canvas.drawBitmap(bitmap, x*GameView.unitW, y*GameView.unitH, paint);
}

Шаг 8. Создаём класс Ship

Теперь создадим класс Ship (космический корабль). Он наследует класс SpaceBody поэтому в определение класа добавим extends SpaceBody.

Напишем конструктор:

public Ship(Context context) {
    bitmapId = R.drawable.ship; // определяем начальные параметры
    size = 5;
    x=7;
    y=GameView.maxY - size - 1;
    speed = (float) 0.2;

    init(context); // инициализируем корабль
}

и переопределим метод update()

@Override
public void update() { // перемещаем корабль в зависимости от нажатой кнопки
    if(MainActivity.isLeftPressed && x >= 0){
        x -= speed;
    }
    if(MainActivity.isRightPressed && x <= GameView.maxX - 5){
        x += speed;
    }
}

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

Шаг 9. Создаём класс Asteroid

Добавим класс Asteroid (астероид). Он тоже наследует класс SpaceBody поэтому в определение класса добавим extends SpaceBody.

Добавим нужные нам переменные:

private int radius = 2; // радиус
private float minSpeed = (float) 0.1; // минимальная скорость
private float maxSpeed = (float) 0.5; // максимальная скорость

Астероид должен появляться в случайной точке вверху экрана и лететь вниз с случайной скоростью. Для этого x и speed задаются при помощи генератора случайных чисел в его конструкторе.

public Asteroid(Context context) {
    Random random = new Random();

    bitmapId = R.drawable.asteroid;
    y=0;
    x = random.nextInt(GameView.maxX) - radius;
    size = radius*2;
    speed = minSpeed + (maxSpeed - minSpeed) * random.nextFloat();

    init(context);
}

Астероид должен двигаться с определённой скорость вертикально вниз. Поэтому в методе update() прибавляем к координате x скорость.

@Override
public void update() {
    y += speed;
}

Так же нам нужен будет метод определяющий столкнулся ли астероид с кораблём.

public boolean isCollision(float shipX, float shipY, float shipSize) {
    return !(((x+size) < shipX)||(x > (shipX+shipSize))||((y+size) < shipY)||(y > (shipY+shipSize)));
}

Рассмотрим его поподробнее. Для простоты считаем корабль и астероид квадратами. Тут я пошёл от противного. То есть определяю когда квадраты НЕ пересекаются.

((x+size) < shipX) — корабль слева от астероида.
(x > (shipX+shipSize)) — корабль справа от астероида.
((y+size) < shipY) — корабль сверху астероида.
(y > (shipY+shipSize)) — корабль снизу астероида.

Между этими четырьмя выражениями стоит || (или). То есть если хоть одно выражение правдиво (а это значит что квадраты НЕ пересекаются) — результирующие тоже правдиво.

Всё это выражение я инвертирую знаком!. В результате метод возвращает true когда квадраты пересекаются. Что нам и надо.

Про определение пересечения более сложных фигур можно почитать тут.

Шаг 10. Добавляем астероиды в GameView

В GameView добавляем переменные:

private ArrayList<Asteroid> asteroids = new ArrayList<>(); // тут будут харанится астероиды
private final int ASTEROID_INTERVAL = 50; // время через которое появляются астероиды (в итерациях)
private int currentTime = 0;

также добавляем 2 метода:

private void checkCollision(){ // перебираем все астероиды и проверяем не касается ли один из них корабля
    for (Asteroid asteroid : asteroids) {
        if(asteroid.isCollision(ship.x, ship.y, ship.size)){
            // игрок проиграл
            gameRunning = false; // останавливаем игру
            // TODO добавить анимацию взрыва
        }
    }
}

private void checkIfNewAsteroid(){ // каждые 50 итераций добавляем новый астероид
    if(currentTime >= ASTEROID_INTERVAL){
        Asteroid asteroid = new Asteroid(getContext());
        asteroids.add(asteroid);
        currentTime = 0;
    }else{
        currentTime ++;
    }
}

И в методе run() добавляем вызовы этих методов перед вызовоом control().

@Override
public void run() {
    while (gameRunning) {
        update();
        draw();
        checkCollision();
        checkIfNewAsteroid();
        control();
    }
}

Далее в методе update() добавляем цикл который перебирает все астероиды и вызывает у них метод update().

private void update() {
    if(!firstTime) {
        ship.update();
        for (Asteroid asteroid : asteroids) {
            asteroid.update();
        }
    }
}

Такой же цикл добавляем и в метод draw().

private void draw() {
    if (surfaceHolder.getSurface().isValid()) {  //проверяем валидный ли surface

        if(firstTime){ // инициализация при первом запуске
            firstTime = false;
            unitW = surfaceHolder.getSurfaceFrame().width()/maxX; // вычисляем число пикселей в юните
            unitH = surfaceHolder.getSurfaceFrame().height()/maxY;

            ship = new Ship(getContext()); // добавляем корабль
        }

        canvas = surfaceHolder.lockCanvas(); // закрываем canvas
        canvas.drawColor(Color.BLACK); // заполняем фон чёрным

        ship.drow(paint, canvas); // рисуем корабль

        for(Asteroid asteroid: asteroids){ // рисуем астероиды
            asteroid.drow(paint, canvas);
        }

        surfaceHolder.unlockCanvasAndPost(canvas); // открываем canvas
    }
}

Вот и всё! Простейшая 2D игра готова. Компилируем, запускаем и смотрим что получилось!
Если кто-то запутался или что-то не работает можно скачать исходник.

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

На этом всё. Пишите отзывы, вопросы, интересующие вас темы для продолжения.

Недавно мы делали веб-игру про сбор пирамиды. Там мы использовали 3Д-движок и симуляцию физики. И в целом получилась залипательная веб-игра. Вот предыдущие этапы: 

Ключевое слово — веб: игра работает только в браузере и только при наличии интернета. На этот раз мы превратим страницу с игрой в полноценное приложение для Android. При этом мы не будем пользоваться онлайн-конструкторами, а сделаем всё по-настоящему — в среде разработки и с кодом на Java.

Наш план таков: 

Результат можно скачать сразу: вот приложение, которое получилось у нас таким нехитрым способом:

 ⭐️ Скачать apk 

Подготовка

Главное, что нам понадобится из инструментов, — официальная среда разработки Android Studio. У нас есть про неё отдельная статья: что это такое, зачем нужно и как установить. Качаем с официального сайта и устанавливаем.

Так как наша игра должна работать без интернета, то это значит, что все ресурсы тоже должны быть доступны локально, прямо с телефона. В HTML-файле мы подключаем два внешних скрипта — их тоже нужно будет скачать:

<!-- подключаем Three.js -->
<script src='https://cdnjs.cloudflare.com/ajax/libs/three.js/r124/three.min.js'></script>
<!-- подключаем Cannon.js -->
<script src='https://cdnjs.cloudflare.com/ajax/libs/cannon.js/0.6.2/cannon.min.js'></script>
<!-- подключаем наш скрипт -->
<script src="./script.js"></script>

Для этого копируем адрес скрипта из кода страницы, вставляем в браузер и сохраняем то, что открылось, как js-файл.

Скрипты кладём в ту же папку, что и остальные файлы с игрой. Вот что должно по итогу у нас получиться с файлами:

После этого исправляем пути к скриптам в html-файле, чтобы они подтягивались из той же папки, а не из интернета:

<!-- подключаем Three.js -->
<script src='three.min.js'></script>
<!-- подключаем Cannon.js -->
<script src='cannon.min.js'></script>
<!-- подключаем наш скрипт -->
<script src="script.js"></script>

Сохраняем страницу и открываем её в браузере. Если мы всё сделали правильно, то «Пирамида» запустится как обычно — с красивой графикой и реакцией на нажатия.

Создаём новый проект в Android Studio

Запускаем Android Studio и выбираем Empty Activity:

После этого выбираем язык Java, а всё остальное оставляем без изменений:

Если это ваш первый запуск, программа начнёт качать разные служебные файлы — это нормально, нужно просто немного подождать.

Когда всё загрузится и запустится, перед нами появится окно с новой программой в Android Studio. 

Добавляем файлы

Чтобы программа смогла загрузить в себя все файлы от игры, нам нужно создать в проекте специальную папку — assets — и скопировать в неё всё, что у нас есть. Для этого нужно пройти несколько неочевидных шагов: 

Создаём папку так: в левой верхней части щёлкаем правой кнопкой мыши по папке app и в появившемся меню выбираем New → Folder → Assets Folder:

Перед нами появится окно, которое спрашивает, к чему будет относиться папка. Ничего не меняем и просто нажимаем Finish:

Теперь щёлкаем правой кнопкой мыши на появившейся папке и выбираем Open in → Explorer:

Перед нами появится окно проводника с нашей папкой assets. Заходим в неё и копируем туда все игровые файлы, которые мы собрали в самом начале:

Смотрим в панель файлов Android Studio, чтобы убедиться, что всё получилось и система увидела наши файлы:

Пишем код

Нам было бы здорово видеть и дизайн, и код, поэтому выбираем слева в колонке файлов res → layouts → activity_main.xml и переключаем вид в режим Split в правом верхнем углу:

В этом же файле activity_main.xml есть блок, который начинается с команды <TextView — удаляем весь блок (название и 7 команд ниже) и вместо него пишем <WebView>. Среда разработки умная, поэтому, как только мы начнём писать код, она автоматически предложит нам создать новый блок. Нажимаем энтер, когда появится подсказка:

Вот команды, которые нужно добавить в этот файл:

<WebView
android:layout_width="match_parent"   
android:layout_height="match_parent"  
android:id="@+id/webview"></WebView>

В итоге у нас должен получиться такой блок:

Нажимаем ⌘+S или Ctrl+S, чтобы всё сохранить .

Теперь переходим к другому файлу — MainActivity.java — и добавляем в него такой код:

setContentView(R.layout.activity_main);
WebView webView=findViewById(R.id.webview);
webView.getSettings().setJavaScriptEnabled(true);
webView.loadUrl("javascript:addLayer(x, z, width, depth, direction)");
webView.loadUrl("javascript:generateBox(x, y, z, width, depth, falls)");
webView.loadUrl("javascript:addOverhang(x, z, width, depth)");
webView.loadUrl("javascript:cutBox(topLayer, overlap, size, delta)");
webView.loadUrl("javascript:init()");
webView.loadUrl("javascript:startGame()");
webView.loadUrl("javascript:eventHandler()");
webView.loadUrl("javascript:splitBlockAndAddNextOneIfOverlaps()");
webView.loadUrl("javascript:missedTheSpot()");
webView.loadUrl("javascript:animation(time)");
webView.loadUrl("javascript:updatePhysics(timePassed)");
webView.loadUrl("javascript:window.addEventListener()");

webView.loadUrl("file:///android_asset/index.html");

Смысл тут в том, что мы сначала создаём новый элемент — просмотрщик веб-контента, потом разрешаем ему выполнять скрипты, а затем перечисляем все функции, которые у нас объявлены в основном скрипте вместе с параметрами вызова. Это нужно для того, чтобы Java знала, что это можно выполнять.

Нажимаем Shift+F10, чтобы запустить приложение в эмуляторе, — видим, что справа появился виртуальный телефон с началом нашей игры, но ничего не двигается. Это связано с тем, что встроенный эмулятор плохо работает с трёхмерной графикой и не может показать всё, что мы от него хотим. Главное, зачем нам это было нужно, — убедиться, что программа нашла все наши файлы, загрузила их и скрипт тоже заработал.

Компилируем приложение

Если нам нужен apk-файл, который можно установить на телефон, чтобы проверить игру по-настоящему, нам надо скомпилировать весь проект. Для этого выбираем в верхнем меню Build → Build Bundle(s) / APK(s) → Build APK(s):

Когда всё будет готово, внизу появится уведомление, что файл готов. Нажимаем на locate, чтобы перейти к файлу в проводнике:

Этот файл можно скачать себе на телефон с Android, установить его и поиграть в «Пирамиду» даже без интернета.

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

Чтобы продемонстрировать, насколько легко написать что-то подобное, сегодня мы напишем свой Flappy Bird с помощью Unity всего за 10 минут.

Игровой персонаж

Сначала создайте новый проект и убедитесь, что выбрана опция 2D.

Загрузите свой спрайт птицы в сцену. Не забудьте включить фантазию!

Затем отрегулируйте размер спрайта как вам нравится, перетягивая его за угол в нужном направлении. Спрайт должен быть виден в окне иерархии (hierarchy) слева. В нём видны все объекты в сцене, и на данный момент их должно быть всего два: камера и птица.

Перетащите камеру на птицу и отпустите. Камера должна оказаться под птицей, это будет значить, что камера теперь «ребёнок» птицы. Теперь позиция камеры будет фиксироваться относительно птицы. Если птица двигается вперёд, то камера делает то же самое.

Снова выберите птицу в сцене или в окне иерархии. Вы увидите список опций и атрибутов справа в окне под названием Inspector. Здесь вы можете управлять различными переменными, привязанными к определённому объекту.

Теперь нажмите на Add Component. Выберите Physics2D > Rigidbody2D — это готовый набор инструкций для применения гравитации к нашему персонажу. Нажмите на Constraints в этой панели и затем выберите freeze rotation Z. Это позволит предотвратить вращение птицы вместе с камерой по кругу.

Таким же образом добавьте Polygon Collider, который говорит Unity, где находятся границы персонажа. Нажмите Play и увидите, как спрайт вместе с камерой бесконечно падает вниз.

Пока всё идёт хорошо!

Теперь пора заняться полётами персонажа, благо это будет несложно.

Сначала нужно создать C#-скрипт. Создайте для него папку (кликните правой кнопкой мыши где-нибудь в assets и создайте папку «Scripts»), сделайте клик правой кнопкой мыши и выберите Create > C# Script.

Назовём его «Character». Кликните по нему дважды, чтобы открыть его в вашей IDE, будь то MonoDevelop или Visual Studio. Затем добавьте следующий код:

public class Character : MonoBehaviour {

    public Rigidbody2D rb;
    public float moveSpeed;
    public float flapHeight;

    // Это нужно для инициализации
    void Start () {
        rb = GetComponent();
    }
      

    // Update вызывается один раз на кадр
    void Update () {
        rb.velocity = new Vector2(moveSpeed, rb.velocity.y);
        if (Input.GetMouseButtonDown(0))
        {
            rb.velocity = new Vector2(rb.velocity.x, flapHeight);
        }

        if (transform.position.y > 18 || transform.position.y < -19)
        {
            Death();
        }

    }

    public void Death()
    {
        rb.velocity = Vector3.zero;
        transform.position = new Vector2(0, 0);
    }

}

Этот код делает две вещи. Он заставляет персонажа двигаться вперёд со скоростью, которую мы определим в инспекторе, и создаёт ощущение полёта птицы. Метод Update() вызывается повторно на протяжении игры, поэтому всё, что вы сюда поместите, будет выполняться непрерывно. В данном случае мы добавляем немного скорости нашему объекту. Переменная rb является скриптом RigidBody2D, который мы применили к нашему объекту ранее, поэтому когда мы пишем rb.velocity, мы обращаемся к скорости объекта.

Тап по экрану интерпретируется Unity как клик мыши, если вы используете мобильное устройство. После нажатия мы заставляем персонажа немного подняться вверх.

Переменная moveSpeed будет отвечать за скорость движения, а переменная flapHeight — за увеличение высоты полёта птицы после каждого нажатия. Поскольку эти переменные объявлены как public, мы сможем изменить их вне скрипта.

Метод Death() тоже объявлен как public, что значит, что другие объекты и скрипты смогут его вызвать. Этот метод просто возвращает положение персонажа в начало. Также он будет использоваться каждый раз, когда персонаж будет залетать слишком высоко или низко. Скоро вы поймёте, почему он объявлен именно как public. Строка rb.velocity = Vector3.zero; нужна, чтобы убрать импульс — мы же не хотим, чтобы после каждой смерти персонаж падал всё быстрее и быстрее?

Теперь можно выходить из IDE и добавлять скрипт как компонент к персонажу. Для этого нужно выбрать нашу птицу и нажать Add Component > Scripts > Character. Теперь мы можем определять moveSpeed и flapHeight в инспекторе (для этого и нужны public-переменные). Присвоим переменным значения 3 и 5 соответственно.

И ещё: в инспекторе нужно добавить тег к персонажу. Для этого кликните там, где написано Tag: Untagged и затем выберите Player в выпадающем списке.

Препятствия

Теперь добавим препятствия: трубы. Кто-то в трубах находит грибы, а кто-то — свою смерть.

Перетащите спрайт трубы в сцену в место, где должно быть первое препятствие, и назовите его pipe_up.
Теперь создадим новый скрипт под названием Pipe:

public class Pipe : MonoBehaviour {

    private Character character;

    // Это нужно для инициализации
    void Start () {
        character = FindObjectOfType();
    }

      
    // Update вызывается один раз на кадр
    void Update () {
        if (character.transform.position.x - transform.position.x > 30)
        {

        }
    }

    void OnCollisionEnter2D(Collision2D other)
    {
        if (other.gameObject.tag == "Player")
        {
            character.Death();  
        }
    }

}

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

Метод OnCollisionEnter2D() вызывается каждый раз при взаимодействии трубы с персонажем. После этого вызывается созданный ранее метод Death(), возвращающий игрока в начальную точку.

Итак, у нас есть одна труба, которая время от времени будет исчезать и появляться на другом конце экрана. Врежешься в неё — умрёшь.

Перевёрнутые трубы

Сейчас у нас есть только один спрайт трубы. Давайте добавим ещё один. Для этого кликните правой кнопкой мыши в окне иерархии, нажмите New 2D Object > Sprite и затем выберите спрайт, который хотите использовать. Ещё проще будет просто перетащить файл в сцену ещё раз.

Назовите этот спрайт pipe_down. В инспекторе в части Sprite Renderer выберите опцию Flip Y, чтобы перевернуть трубу вверх ногами. Добавьте такое же RigidBody2D.

Теперь напишем новый C#-скрипт под названием PipeD. В нём будет похожий код:

public class PipeD : MonoBehaviour {

    private Character character;

    //Это нужно для инициализации
    void Start()
    {
        character = FindObjectOfType();
    }

    // Update вызывается один раз на кадр
    void Update()
    {
        if (character.transform.position.x - transform.position.x > 30)
        {
        }

    }

    void OnCollisionEnter2D(Collision2D other)
    {
        if (other.gameObject.tag == "Player")
        {
            character.Death();
        }

    }

}

Префабы

Итак, нам достаточно этого кода, чтобы сделать всю игру. Мы могли бы передвигать трубы на правую сторону экрана каждый раз, когда они исчезают, или скопировать и вставить столько труб, сколько мы хотели бы встретить на протяжении всей игры.

Если пойти первым путём, то убедиться, что трубы стоят как надо после случайной генерации, и поддерживать честный ход вещей было бы сложно. После смерти персонажа они могли бы появиться в километрах от первой трубы!

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

Вместо этого давайте воспользуемся префабами. Если говорить просто, то мы превратим наши трубы в шаблоны, которые потом сможем использовать для эффективного создания большего количества труб по желанию. Если тут есть программисты, то считайте скрипт Pipe классом, а трубы — экземплярами этого объекта.

Для этого создайте новую папку «Prefabs». Затем перетащите pipe_up и pipe_down из окна иерархии в папку.

Каждый раз, когда вы перетаскиваете объект из этой папки в сцену, у него будут те же свойства, поэтому вам не нужно будет постоянно добавлять компоненты. Более того, если вы измените размер компонента в папке, это повлияет на все трубы в игре, и вам не придётся изменять каждую из них отдельно.

Как вы понимаете, это сильно сэкономит наши ресурсы. Также это означает, что мы можем взаимодействовать с объектами из кода. Мы можем создавать экземпляры наших труб.

Сначала добавьте этот код в условное выражение в методе Update()  скрипта Pipe, которое мы оставили пустым:

void Update () {
        if (character.transform.position.x - transform.position.x > 30)
        {

            float xRan = Random.Range(0, 10);
            float yRan = Random.Range(-5, 5);

            Instantiate(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation);
            Destroy(gameObject);

        }

    }

Это нужно для создания экземпляра нашего gameObject. В результате получается новая идентичная копия. В Unity всегда, когда вы используете слово gameObject, оно ссылается на объект, к которому скрипт в данный момент привязан — в нашем случае к трубе.

Мы генерируем заново наши трубы в случайных вариациях, чтобы было повеселее.

Но вместо того, чтобы проделывать всё то же в скрипте PipeD , мы генерируем оба объекта в одном месте. Таким образом мы можем легко устанавливать положение второй трубы относительно первой. Также это значит, что нам нужно меньше кода для PipeD.

Создайте public gameObject с именем pipeDown. Затем обновите код следующим образом:

if (character.transform.position.x - transform.position.x > 30)
        {

            float xRan = Random.Range(0, 10);
            float yRan = Random.Range(-5, 5);
            float gapRan = Random.Range(0, 3);

            Instantiate(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation);
            Instantiate(pipeDown, new Vector2(character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation);
            Destroy(gameObject);

        }

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

Возвращаемся обратно в Unity и перетаскиваем префаб pipe_down из папки с префабами (это важно!) в место, где написано  «Pipe Down» (заметьте, как наш camel case заменяется пробелом) на спрайт трубы pipe up. Если вы помните, мы определили Pipe Down как public gameObject, что даёт нам возможность определять, чем является этот объект откуда угодно – в данном случае через инспектор. Выбирая префаб для этого объекта, мы убеждаемся, что при создании экземпляра трубы он будет включать в себя все атрибуты и скрипт, которые мы добавили ранее. Мы не просто создаём спрайт, но пересоздаём объект с коллайдером, который может убить персонажа.

Всё, что мы добавим в то же место в скрипте PipeD —  просто Destroy(gameObject),  чтобы труба саморазрушалась при выходе за левую границу экрана.

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

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

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

Бесконечный полёт

Теперь создадим public-переменные pipe_up и pipe_down в скрипте Character. Это даст вам возможность ссылаться на созданные объекты, перетаскивая префабы на объект персонажа, прямо как когда мы добавили pipe_down в скрипт Pipe.

Нам нужно добавить эти переменные:

public GameObject pipe_up;
public GameObject pipe_down;

Затем мы напишем такой метод:

 public void BuildLevel()
    {
        Instantiate(pipe_down, new Vector3(14, 12), transform.rotation);
        Instantiate(pipe_up, new Vector3(14, -11), transform.rotation);

        Instantiate(pipe_down, new Vector3(26, 14), transform.rotation);
        Instantiate(pipe_up, new Vector3(26, -10), transform.rotation);

        Instantiate(pipe_down, new Vector3(38, 10), transform.rotation);
        Instantiate(pipe_up, new Vector3(38, -14), transform.rotation);

        Instantiate(pipe_down, new Vector3(50, 16), transform.rotation);
        Instantiate(pipe_up, new Vector3(50, -8), transform.rotation);

        Instantiate(pipe_down, new Vector3(61, 11), transform.rotation);
        Instantiate(pipe_up, new Vector3(61, -13), transform.rotation);

    }

Мы будем вызывать его один раз в методе Update() и один раз в методе Death().

После начала игры вызывается Update(), и наши трубы ставятся согласно заданной конфигурации. За счёт этого первые несколько препятствий всегда будут стоять на одном и том же месте. После смерти игрока трубы встанут на те же самые места.

Вернитесь в сцену в Unity и удалите две трубы, которые сейчас там находятся. Ваша «игра» будет выглядеть просто как пустой экран с птицей. Нажмите Play и трубы появятся, после нескольких первых их положение будет определяться случайным образом.

В заключение

Вот мы и сделали целую игру! Добавьте счётчик очков, попробуйте сделать его более оригинальным и увеличивайте сложность игры по мере продвижения. Также не будет лишним сделать меню. Ещё хорошей идеей будет уничтожать трубы на экране после смерти персонажа. Как только вы с этим закончите — считайте, что готовая к выпуску в Play Store игра у вас в кармане! Когда-то похожая игра сделала другого разработчика очень богатым, и это доказывает, что вам не нужно быть гением-программистом или иметь за своей спиной богатого издателя, чтобы достичь успеха. Вам просто нужна хорошая идея и десять минут!

Хотите писать приложения под Android, но не знаете, с чего начать? Тогда ознакомьтесь с нашей большой подборкой ресурсов для изучения Android-разработки.

Перевод статьи «Flappy Bird Unity tutorial for Android – Full game in 10 minutes!»

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

Выбираем способ разработки 

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

• Онлайн на специальных сайтах. Существует огромное количество ресурсов в сети Интернет, предлагающих создание собственной игры на базе предлагаемых шаблонов. От пользователя может даже не потребоваться регистрация на сайте. Для создания игровой сцены потребуется подобрать персонажей, настроить окружение, добавить объекты для взаимодействия, а также использовать определенный сценарий и установить необходимые дополнительные опции. Для данного метода не потребуется тратить много времени и глубокие познания языков программирования. Однако же в этом случае и не получится создать уникальный компонент, так как в распоряжении исключительно готовые инструменты. 
• Если вы желаете создавать игры без подключения к Интернет или вам необходимо большее количество шаблонов, то в таком случае оптимальным будет выбор в пользу специализированных программ, принцип действия которых аналогичен онлайн-сервисам, но предоставляется выбор большего количества стандартных компонент. При желании можно расширить функциональность софта за счет установки дополнительных шаблонов или кастомизации графики. 
• Использование специальных сред разработки подойдет для опытных программистов, которые умеют писать на языках C, Python, Java и других. Этот способ позволяет сделать игру на Андроид практически полностью своими руками с нуля. Для ускорения процесса создания можно вставлять готовые стандартные блоки кода. То есть в средах разработки нет никаких ограничений в полете фантазии, вы сможете создать свою игру в полном соответствии с разработанным сценарием. Затраты времени на разработку будут в несколько раз превышать предыдущие 2 способа, но оно того стоит. 

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

Что потребуется для создания игры? 

Перед тем как создать игру на Андроид необходимо продумать следующий ряд вопросов: 

• Разработать основную концепцию и подобрать жанр. Условия геймплея должны соответствовать заданному стилю, если совместить несколько типов игры в одной, то в таком случае у игрока создастся определенный конфликт, ведь никто не сможет дать гарантии, что они одновременно понравятся и он будет играть дальше. 
• Разработать сценарий, который по мере прохождения будет раскрываться, подогревая интерес у пользователя. Важно, чтобы он полностью соответствовал той аудитории, на которую рассчитана игра, в противном случае она скорее всего покажется скучной. 
• Проработать графику. От качества прорисовки персонажей, объектов для взаимодействия и общей атмосферы полностью зависят впечатления игрока, которые он будет испытывать по мере прохождения уровней. 
• Продумать уровни сложности, чтобы любой пользователь смог получать удовольствие от геймплея, а не раздражение из-за непроходимости локаций. 

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

Выбираем жанр 

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

• Головоломки. Они помогают развивать мышление и реакцию, поскольку решения нужно принимать быстро и грамотно. Данный тип игр считается одним из самых распространенных благодаря тому, что они имеют минимальные требования к аппаратному и программному обеспечению, а также интересны широкому кругу пользователей. Обязательно нужно продумать механики взаимодействия персонажа с предметами или отдельных объектов. 
• Казуальные игры. Ориентированы на игроков всех возрастов, так как позволяют проходить уровни на одном дыхании, наслаждаясь локациями. Пользователь управляет персонажем и выполняет задачи, преимущественно сбор каких-то предметов или убивая врагов, а при выполнении миссий переходит на следующий уровень. Геймплей захватывающий за счет качественной графики и незатейливого сюжета. 
• MMORPG. Многопользовательские онлайн-игры, происходящие на определенных картах или в открытом игровом мире, где основной сюжет связан с непосредственным взаимодействием с персонажами, управляемыми другими пользователями. Преимущество данного типа игр как раз в этом и заключается, что влияние ИИ минимально, а поведение других геймеров совершенно непредсказуемо. 
• Battle Royale. Целью является победа над противниками на выбранной локации, которая со временем уменьшается и заставляет врагов сближаться для финального сражения. То есть выигрывает последний выживший. 
• MOBA. Совмещает в себе элементы стратегии и экшена. Игрок управляет персонажем, который должен построить свою базу, создать юнитов, а затем победить противников.  

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

Выбираем движок 

Прежде чем создать игру на Андроид необходимо подобрать движок, на котором она будет разрабатываться: 

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

• Unreal Engine. Движок с потрясающими возможностями в графике, который реализован на C++. Благодаря использованию передовых технологий можно создавать конкурентные мобильные игры. 

• Solar2D. Движок, в котором сценарии прописываются при помощи языка Lua. В нем есть множество стандартных плагинов и инструментов для разработки. Недостатком является отсутствие возможности создания 3D моделей. 

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

Этапы разработки 

Создание игр выполняется в несколько этапов: 

• Создание идеи и плана. Важно, чтобы был уникальным сценарий и геймплей, чтобы готовый проект понравился аудитории. В данной ситуации внесение небольших изменений в готовые игры и выдача их за уникальные не получится, поскольку в таком случае затраты не будут окуплены в будущем из-за низкого интереса геймеров. 
• Выбор движка и инструментов разработки. На этом этапе потребуется заранее определить, какие цели стоят и размер бюджета, стоит ли пользоваться услугами наемных программистов. Если есть собственный опыт и знания, то с небольшими проектами можно справиться своими силами. В противном случае пока будет проходить разработка, то идея может стать неактуальной. 
• Создать графическое оформление. Оно подбирается с целью создания единой атмосферы, в которую мог бы полностью погрузиться геймер. Важны проработки всех деталей, чтобы представить миру достойный продукт и эффективно противостоять конкурентам. 
• Тщательное тестирование проекта для выявления багов и своевременного их устранения. 
• Публикация и монетизация. Большинство игр создается ради заработка или хотя бы возврата вложенных в ее разработку средств. Поэтому ее не стоит откладывать на полку, а лучше опубликовать в Play Market. Таким образом появится возможность представить проект широкой аудитории, а также получить отзывы. 

Стоит отметить тот факт, что для заработка на проекте требуется его постоянно развивать и совершенствовать. 

Заключение 

Сфера гейм девелопмента для Андроид является одним из самых популярных направлений в программировании. Поэтому стоит попробовать свои силы в создании уникального игрового проекта.

Хочу поведать вам свою историю, как мне удалось сделать мобильную RPG игру в одиночку, без программирования и бюджета. Это был непростой путь, длинной в целых 2 года. Но чтобы вы лучше понимали всю историю расскажу для начала с чего всё начиналось.

JAVA игры

Я фанат мобильных игр. Возможно кто помнит, лет десять-пятнадцать назад у всех были кнопочные мобильные телефоны, в которых можно было загружать java приложения. Это могли быть как простенькие аркады, так и вполне серьёзные RPG и стратегические игры. Каждая такая серьёзная игра не переставляла удивлять глубиной и разнообразием. И как только разработчикам удавалось вопреки всем аппаратным и программным ограничениям делать настолько глубокие шедевры?!

Это были игры, в которых ещё не было никакого free-to-play. Каждая новая игра была открытием. Чувствовалось, что разработчики вкладывали душу в свои проекты. И делали свою работу максимально качественной, чтобы игроки покупали их игры снова и снова. С большими надеждами я ждал то время, когда производительность мобильных устройств возрастёт, а вместе с ней увеличится и масштаб игр.

Android игры

И первое время так и было. Помните первые крупные мобильные игры, которые появлялись на новых смартфонах? Galaxy on Fire 2, серия Asphalt, Modern Combat. Удивительно, но все эти игры являются портами одноименных java-хитов. Время шло вперёд, стали появляться всё более и более мощные устройства. Увеличивались размеры экранов. И вроде бы вот она, золотая эпоха мобильных игр, когда полёт творческой мысли создателей уже больше ничем не ограничен.

Но, к сожалению, с каждым годом игры всё больше и больше переставали быть местом для творчества. Теперь это крупный бизнес, в котором крутятся большие деньги. Больше никаких новых идей, только копирование друг друга. Мне, как ценителю стратегий и RPG стало больно смотреть во что превратились современные игры. Теперь, стратегиями называют всякого рода фермы, которые клонируют геймплей либо Clash of Clans, либо Game of War. На игроков многие разработчики смотрят лишь как на кошелёк с деньгами, который нужно регулярно трясти, чтобы получить больше денег.

А самое большое разочарование, что в современных играх, деньги стали решающим фактором, определяющим успех игрока. Хочешь мощное оружие — только сегодня и только для вас, новый меч «Пожинатель душ 2000» всего за 9.99$. Хочешь улучшить цитадель — жди 999 лет или заплати 299 рубинов(кристаллов/золота/кредитов/алмазов, подчеркнуть нужное) и сможешь построить здание прямо сейчас. Хочешь побеждать, не прикладывая ради этого никаких умственных усилий — заплати 4.99$ и сможешь победить Васю в неравном бою, имея огромное преимущество.

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

Стартовые условия

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

Откуда была взята идея

Несколько лет я играл мобильную стратегию под названием Galaxy Legend. Суть игры проста — у нас есть космические корабли, каждый из которых обладает своим набором характеристик плюс специальное умение. Бои проходят автоматически, по особой пошаговой механике. Задача игрока в том, чтобы собрать максимально эффективный флот и придумать эффективную расстановку кораблей, учитывающую особенности вашего флота и вражеского.

Идея замечательная, но как и в любой другой современной мобильной стратегии, здесь был очень сильный донат. За деньги другие игроки могли покупать более крутые корабли и лучше прокачивать любые характеристики. Тактика и стратегия уступала месту тугому кошельку. Играя без доната (или с относительно небольшим донатом) прокачка вашего аккаунта напрямую зависела от влияния рандома. Вам может повезёт и вы получите из ящика заветный корабль. А может и не получите. За N-сумму денег вы получаете корабль гарантированно. И так практически с каждым аспектом игры.

Потому я решил взять за основу боевую механику из Galaxy Legend, где-то её упростить, а где-то сделать более сложной и продуманной. Упор я решил сделать в разнообразии способов прокачки. Вы сражаетесь, зарабатываете ресурсы, вкладываете их в прокачку нужного вам билда и сражаетесь дальше, имея более лучший корабль и более сложных и интересных соперников.

Сложность и глубина игры

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

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

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

Таким образом, любой ваш корабль обладает своим собственным набором преимуществ и недостатков. Точно также, как и корабли противника. Это своего рода головоломка, которую игроку необходимо решить. И против каждого серьёзного врага необходимо корректировать свою тактику: выбрать другое умение, переназначить должности членам экипажа, установить другой набор энергитических кристаллов и т.д.

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

Разумеется, можно играть и не думая, просто качать корабль, нажимать кнопку «в бой» и удивляться своим поражением. Но игра — это всего лишь инструмент, который может стать мощным оружием в одних руках и бесполезным в других.

Замена донатных механик

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

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

Монетизация

Итак, я решил делать игру без доната. Но как же разработчику заработать на хлеб с маслом? Делать игру платной — означает похоронить её ещё до выхода, т.к. мало кто рискнет потратить деньги на игру от никому неизвестного разработчика. Пожертвования, на мой взгляд, работают только в случае крупных и хорошо раскрученных проектов. Потому, остаётся только реклама. Но превращать игру в рекламную помойку тоже не хочется. Значит, реклама должна быть только вознаграждаемой.

Поскольку в игре нет таймеров, то доступ к новому контенту напрямую зависит от количества вложенных в прокачку ресурсов. Соответственно, было решено добавить в награду за просмотр рекламы игровые ресурсы. Всё по-честному — можешь получать ресурсы в кликере, а можешь один раз в 5 минут посмотреть рекламное видео и получишь на выбор три случайно сгенерированных пакета с ресурсами.

Движок

После недолгих поисков движков, позволяющих делать игры без программирования, выбор пал на Construct 2. Принцип его работы в том, что у нас есть сцена (где мы расставляем объекты), есть сами объекты и есть лист событий, в котором мы вручную прописываем события (состоящие из условий и действий), т.е. взаимодействие объектов друг с другом. События можно объединять в группы, можно делать подсобытия с дополнительными условиями. Объектам можно задавать свойства, поведение, переменные и т.д. По-сути, можно реализовать абсолютно любую игровую механику (в рамках 2D игры). Всё упирается в вашу фантазию и умение решать логические задачи.

В современном геймдев сообществе считается немного неприличным признаться, что ты делаешь игру без программирования. Почему-то есть стереотип, что игры без программирования обязательно используют какие-то шаблоны, что в них отсутствует уникальность и что есть какие-то ограничения, не позволяющие реализовать сложные идеи. На мой взгляд, подобные суждения — лишь миф, порожденный большим количеством низкосортных игр, сделанных на коленке за 5 минут. Но виноват ли в этом движок?!

На своей практике я так ни разу и не столкнулся с какими-либо ограничениями, когда бы я ощущал необходимость программирования. Более того, по моему глубокому убеждению, качество готовой игры зависит не от навороченности движка, а от прямоты рук разработчика. Движок — это не более чем инструмент. Игра сама себя не сделает, какой бы крутой движок вы не использовали. А конечному потребителю (игроку) вообще не важно на каком движке вы сделали игру.

Визуальный стиль

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

До того, как я взялся за разработку своей игры, у меня был опыт в написании обучающих статей и гайдов на игровую тематику. Этот опыт формирует навык смотреть на игры с точки зрения новичка. В свою очередь, этот навык помог мне сделать интерфейс достаточно гибким и интуитивно понятным (учитывая всю сложность и глубину игры).

Фичекат

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

От чего пришлось отказаться (основное):

1. Мультиплеер. Да-да. Свою первую игру я хотел сразу же сделать с мультиплеером. Самой трудно задачей в этом деле было придумать, как сделать защиту от нечестных игроков. Даже топовые онлайн игры вкладывают огромное количество ресурсов в защиту своей игры от взлома. Куда уж там мне, в одиночку бороться против читеров..

Чтобы создать хотя бы минимальную защиту нужно делать для игры серверную часть. А для этого нужно знать на продвинутом уровне серверные технологии, базы данных, php, MySQL и AJAX. Как оказалось, это слишком сложная задача для одного человека, который трудится над своей первой игрой.

2. Открытый мир и сложные игровые режимы. Чтобы игровой процесс был ещё более масштабным мне хотелось добавить в него т.н. «глобальный геймплей». Открытый мир, фракции, торговля, война корпораций и чтобы игрок во всём этом активно участвовал.

Однако позже я понял, что реализация подобных идей, продумывание всех деталей и мелочей займёт столько времени, которое я просто не могу себе выделить. Сложность ещё в том, что когда ты делаешь игру, которую никто не ждёт и о которой никто ничего не знает, то есть неприятное чувство, будто ты делаешь что-то «в пустоту». Потому, чем скорее в твою игру начнут играть реальные люди, чем быстрее ты начнёшь получать отзывы от своей аудитории — тем лучше.

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

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

Создание промо-материалов

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

Иконка

За основу иконки взял спрайт космического корабля из своей же игры. Просто и минималистично. Возможно, в будущем воспользуюсь услугами художника для создания профессиональной иконки для приложения.

Скриншоты

На мой взгляд, задача скриншотов — это объяснить новичку, что примерно представляет из себя игра. Потому не стал слишком подробно демонстрировать различные аспекты прокачки, только всё самое основное.

Трейлер

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

Что я понял в процессе разработки

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

1. Делайте игру для себя. Это моё главное правило. Если для вас создание игр — это, прежде всего, творчество, то делайте игру такой, в которую вы бы сами с огромным удовольствием играли. Не пытайтесь угодить всем, ведь люди все разные и вкусы у всех сильно отличаются. Одни люди предпочитают мясо, другие капусту. Если вы будете делать голубцы, то вероятно, ваша игра может не понравится ни тем, ни другим. Со временем вашу игру найдут люди со схожими игровыми предпочтениями. И это будет ваша самая преданная аудитория.

2. Научитесь адекватно смотреть на свои возможности. Если вы хотите сделать убийцу World of Warcraft, то вам нужно понимать, что у вас нет такого количества опыта, времени и денег, необходимых для создания AAA-игры. Такие игры создаются годами командами в несколько десятков, а то и сотни человек. И у каждого из них есть своя профильная задача: кто-то занимается боевой анимацией, кто-то текстурирует растительность, а кто-то программирует игровую физику. Одному человеку и жизни не хватит, чтобы потянуть всё это.

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

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