Многие программисты так или иначе имеют тягу и интерес к разработке игр. Немалое количество спецов было замечено за написанием маленьких и миленьких игрушек, которые были разработаны за короткое время «just for fun». Большинству разработчиков за счастье взять готовый игровой движок по типу Unity/UE и попытаться создать что-то своё с их помощью, особенно упорные изучают и пытаются что-то сделать в экзотических движках типа Godot/Urho, а совсем прожжённые ребята любят писать игрушки… с нуля. Таковым любителем писать все сам оказался и я. И в один день мне просто захотелось написать что-нибудь прикольное, мобильное и обязательно — двадэшное! В этой статье вы узнаете про: написание производительного 2D-рендерера с нуля на базе OpenGL ES, обработку «сырого» ввода в мобильных играх, организацию архитектуры и игровой логики и адаптация игры под любые устройства. Интересно? Тогда жду вас в статье!

❯ Как это работает?

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


Один из прошлых проектов — 3D шутэмап под… коммуникаторы с Windows Mobile без видеоускорителей! Игра отлично работала и на HTC Gene, и на QTek S110!

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


Подобные инструменты включают в себя как довольно функциональные конструкторы игр, которые обычно не требуют серьёзных навыков программирования и позволяют собирать игру из логических блоков, так и полноценных игровых движков на манер Unity или Unreal Engine, которые позволяют разработчикам писать игры и продумывать их архитектуру самим. Можно сказать что именно «благодаря» доступности подобных инструментов мы можем видеть текущую ситуацию на рынке мобильных игр, где балом правят очень простые и маленькие донатные игрушки, называемые гиперкежуалом.

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

• Большой вес приложения: При сборке, Unity и UE создают достаточно объёмные пакеты из-за большого количества зависимостей. Таким образом, даже пустой проект может спокойно весить 50-100 мегабайт.
• Неоптимальная производительность: И у Unity, и у UE очень комплексные и сложные рендереры «под капотом». Если сейчас купить дешевый смартфон за 3-4 тысячи рублей и попытаться на него накатить какой-нибудь 3 в ряд, то нас ждут либо вылеты, либо дикие тормоза.

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

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

❯ Определяемся с задачами

Перед тем, как садится и пилить игрушку, нужно сразу же определится с целями и поставить перед собой задачи — какой стек технологий мы будет использовать, как будем организовать игровую логику, на каких устройствах игра должна работать и.т.п. Я прикинул и решил реализовать что-то совсем несложное, но при этом достаточно динамичное и забавное… 2D-шутер с видом сверху!


Игра будет написана полностью на Java — родном языке для Android-приложений. Пустые пакеты без зависимостей весят всего около 20 килобайт — что только нам на руку! Ни AppCompat, ни какие либо ещё библиотеки мы использовать не будем — нам нужен минимальный размер из возможных!

Итак, что должно быть в нашей игре:

• Основная суть: Вид сверху, человечком по центру экрана можно управлять и стрелять во вражин. Цель заключается в том, чтобы набрать как можно больше очков перед тем, как игрока загрызут. За каждого поверженного врага начисляются баксы, за которые можно купить новые пушки!
• Оружие: Несколько видов вооружения, в том числе пистолеты, дробовики, автоматы и даже пулеметы! Всё оружие можно купить в внутриигровом магазине за валюту, которую игрок заработал во время игры
• Враги: Два типа врагов — обычный зомби и «шустрик». Враги спавнятся в заранее предусмотренных точках и начинают идти (или бежать) в сторону игрока с целью побить его.
• Уровни: Можно сказать, простые декорации — на момент написания статьи без какого либо интерактива.

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

• Графика: Аппаратно-ускоренный рендерер полупрозрачных 2D-спрайтов с возможность аффинных трансформаций (поворот/масштаб/искривление и.т.п). На мобильных устройствах нужно поддерживать число DIP'ов (вызовов отрисовки) как можно ниже — для этого используется техника батчинга. Сам рендерер работает на базе OpenGLES 1.1 — т.е чистый FFP.
• Ввод: Обработка тачскрина и геймпадов. Оба способа ввода очень легко реализовать на Android — для тачскрина нам достаточно повесить onTouchListener на окно нашей игры, а для обработки кнопок — ловить события onKeyListener и сопоставлять коды кнопок с кнопками нашего виртуального геймпада.
• Звук: Воспроизведение как «маленьких» звуков, которые можно загрузить целиком в память (выстрелы, звуки шагов и… т.п), так и музыки/эмбиента, которые нужно стримить из физического носителя. Тут практически всю работу делает за нас сам Android, для звуков есть класс — SoundPool (который, тем не менее, не умеет сообщать о статусе проигрывания звука), для музыки — MediaPlayer. Есть возможность проигрывать PCM-сэмплы напрямую, чем я и воспользовался изначально, но с ним есть проблемы.
• «Физика»: Я не зря взял этот пункт в кавычки. :) По сути, вся физика у нас — это один метод для определения AABB (пересечения прямоугольник с прямоугольником). Всё, ни о какой настоящей физике и речи не идет. :)

Поэтому, с учетом требований описанных выше, наша игра будет работать практически на любых смартфонах/планшетах/тв-приставках кроме китайских смартфонов на базе чипсета MT6516 без GPU из 2010-2011 годов. На всех остальных устройствах, включая самый первый Android-смартфон, игра должна работать без проблем. А вот и парк устройств, на которых мы будем тестировать нашу игру:



С целями определились, самое время переходить к практической реализации игры! По сути, её разработка заняла у меня около дву-трех дней — это с учетом написания фреймворка. Но и сама игра совсем несложная :)

❯ Рендерер

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

private void attachMainLoop() {
        GLView.setRenderer(new GLSurfaceView.Renderer() {
            @Override
            public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
                Engine.log("GL context successfully created");
                Engine.log("Vendor: %s", GLES10.glGetString(GLES10.GL_VENDOR));
                Engine.log("Renderer: %s", GLES10.glGetString(GLES10.GL_RENDERER));

                Text = new TextRenderer();

                setupRenderState();
                Engine.Current.loadResources();
            }

            @Override
            public void onSurfaceChanged(GL10 gl10, int w, int h) {
                DeviceWidth = w;
                DeviceHeight = h;

                GLES10.glMatrixMode(GLES10.GL_PROJECTION);
                GLES10.glLoadIdentity();
                GLES10.glOrthof(0, w, h, 0, 0, 255);

                Camera.autoAdjustDistance(w, h);

                Engine.log("New render target resolution: %dx%d", w, h);
            }

            @Override
            public void onDrawFrame(GL10 gl10) {
                Engine.Current.drawFrame();
            }
        });
        GLView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);

        Engine.Current.MainActivity.setContentView(GLView);
    }

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

• Установка ортографической матрицы в фиксированные размеры: Если координатная система уже была завязана на пиксели, или по какой-то причине хочется использовать именно её, то можно просто завязать игру на определенном разрешении (например, 480x320, или 480x800). Растеризатор формально не оперирует с пикселями — у него есть нормализованные координаты -1..1 (где -1 — начало экрана, 0 — середина, 1 — конец, это называется clip-space), а матрица проекции как раз и переводит координаты геометрии в camera-space координатах в clip-space — т.е в нашем случае, автоматически подгоняет размеры спрайтов из желаемого нами размера в физический. Обратите внимание, физические движки обычно рассчитаны на работу в метрических координатных системах. Попытки задавать ускорения в пикселях вызывают рывки и баги.
• Перевод координатной системы с пиксельной на метрическую/абстрактную:
  Сейчас этот способ используется чаще всего, поскольку именно его используют самые популярные движки и фреймворки. Если говорить совсем просто — то мы задаем координаты объектов и их размеры не относительно пикселей, а относительно размеров этих объектов в метрах, или ещё какой-либо абстрактной системы координат. Этот подход близок к обычной 3D-графике и имеет свои плюшки: например, можно выпустить HD-пак для вашей игры и заменить все спрайты на варианты с более высоким разрешением, не переделывая половину игры.

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

public void drawSprite(Sprite spr, float x, float y, float width, float height, float z, float rotation, Color col) {
        if(spr != null) {
            if(col == null)
                col = Color.White;

            if(width == 0)
                width = spr.Width;

            if(height == 0)
                height = spr.Height;

            // Convert position from world space to screen space
            x = x - Camera.X;
            y = y - Camera.Y;

            if(x > ViewWidth || y > ViewHeight || x + width < 0 || y + height < 0) {
                Statistics.OccludedDraws++;

                return;
            }

            GLES10.glEnable(GLES10.GL_TEXTURE_2D);
            GLES10.glBindTexture(GLES10.GL_TEXTURE_2D, spr.TextureId);

            GLES10.glMatrixMode(GLES10.GL_MODELVIEW);
            GLES10.glLoadIdentity();
            GLES10.glTranslatef(x + (width / 2), y + (height / 2), 0);
            GLES10.glRotatef(rotation, 0, 0, 1);
            GLES10.glTranslatef(-(width / 2), -(height / 2), 0);
            GLES10.glScalef(width, height, 1.0f);

            vertex(0, 0, 0, 0, col);
            vertex(1, 0, 1, 0, col);
            vertex(1, 1, 1, 1, col);
            vertex(0, 0, 0, 0, col);
            vertex(0, 1, 0, 1, col);
            vertex(1, 1, 1, 1, col);
            vPosBuf.rewind();
            vColBuf.rewind();
            vUVBuf.rewind();

            GLES10.glVertexPointer(2, GLES10.GL_FLOAT, 0, vPosBuf);
            GLES10.glColorPointer(4, GLES10.GL_FLOAT, 0, vColBuf);
            GLES10.glTexCoordPointer(2, GLES10.GL_FLOAT, 0, vUVBuf);

            GLES10.glDrawArrays(GLES10.GL_TRIANGLES, 0, 6);

            Statistics.DrawCalls++;

            }
    }

private void vertex(float x, float y, float u, float v, Color col) {
        vPosBuf.putFloat(x);
        vPosBuf.putFloat(y);
        vColBuf.putFloat(col.R);
        vColBuf.putFloat(col.G);
        vColBuf.putFloat(col.B);
        vColBuf.putFloat(col.A);
        vUVBuf.putFloat(u);
        vUVBuf.putFloat(v);
    }

Всё более чем понятно — преобразуем координаты спрайта из world-space в camera-space, отсекаем спрайт, если он находится за пределами экрана, задаем стейты для GAPI (на данный момент, их всего два), заполняем вершинный буфер геометрией и рисуем на экран. Никакого смысла использовать VBO здесь нет, а на nio-буфферы можно получить прямой указатель без лишних копирований, так что никаких проблем с производительностью не будет. Обратите внимание — вершинный буфер выделяется заранее — аллокации каждый дравколл нам не нужны и вредны.

        // Vertex format:
        //   vec2 pos; -- 8 bytes
        //   vec4 color; -- 16 bytes
        //   vec2 uv; -- 8 bytes
        //   32 bytes total
        int numVerts = 6;
        vPosBuf = ByteBuffer.allocateDirect((4 * 8) * numVerts);
        vColBuf = ByteBuffer.allocateDirect((4 * 16) * numVerts);
        vUVBuf = ByteBuffer.allocateDirect((4 * 8) * numVerts);
        vPosBuf.order(ByteOrder.LITTLE_ENDIAN);
        vColBuf.order(ByteOrder.LITTLE_ENDIAN);
        vUVBuf.order(ByteOrder.LITTLE_ENDIAN);

Обратите внимание на вызовы ByteBuffer.order — это важно, по умолчанию, Java создаёт все буферы в BIG_ENDIAN, в то время как большинство Android-устройств — LITTLE_ENDIAN, из-за этого можно запросто накосячить и долго думать «а почему у меня буферы заполнены правильно, но геометрии на экране нет!?».


В процессе разработки игры, при отрисовке относительно небольшой карты с большим количеством тайлов, количество вызовов отрисовки возросло аж до 600, из-за чего FPS в игре очень сильно просел. Связано это с тем, что на старых мобильных GPU каждый вызов отрисовки означал пересылку состояния сцены видеочипу, из-за чего мы получали лаги. Фиксится это довольно просто: реализацией батчинга — специальной техники, которая «сшивает» большое количество спрайтов с одной текстурой в один и позволяет отрисовать хоть 1000, хоть 100000 спрайтов в один проход! Есть два вида батчинга, статический — когда объекты «сшиваются» при загрузке карты/в процессе компиляции игры (привет Unity) и динамический — когда объекты сшиваются прямо на лету (тоже привет Unity). На более современных мобильных GPU с поддержкой GLES 3.0 есть также инстансинг — схожая технология, но реализуемая прямо на GPU. Суть её в том, что мы передаём в шейдер параметры объектов, которые мы хотим отрисовать (матрицу, настройки материала и.т.п) и просим видеочип отрисовать одну и ту же геометрию, допустим, 15 раз. Каждая итерация отрисовки геометрии будет увеличивать счетчик gl_InstanceID на один, благодаря чему мы сможем расставить все модельки на свои места! Но тут уж справедливости ради стоит сказать, что в D3D10+ можно вообще стейты передавать на видеокарту «пачками», что здорово снижает оверхед одного вызова отрисовки.


Для загрузки спрайтов используется встроенный в Android декодер изображений. Он умеет работать в нескольких режимах (ARGB/RGB565 и.т.п), декодировать кучу форматов — в том числе и jpeg, что положительно скажется на финальном размере игры.

public void upload(ByteBuffer data, int width, int height, int format) {
        if(data != null) {
            int len = data.capacity();

            GLES10.glEnable(GLES10.GL_TEXTURE_2D);
            GLES10.glBindTexture(GLES10.GL_TEXTURE_2D, TextureId);
            GLES10.glTexImage2D(GLES10.GL_TEXTURE_2D, 0, GLES10.GL_RGBA, width, height, 0, GLES10.GL_RGBA, GLES10.GL_UNSIGNED_BYTE, data);
            GLES11.glTexParameteri(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE_MIN_FILTER, GLES10.GL_NEAREST);
            GLES11.glTexParameteri(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE_MAG_FILTER, GLES10.GL_NEAREST);

            Width = width;
            Height = height;
        }
    }

    public static Sprite load(String fileName) {
        InputStream is = null;
        try {
            is = Engine.Current.MainActivity.getAssets().open("sprites/" + fileName);

            BitmapFactory.Options opts = new BitmapFactory.Options();
            opts.inPreferredConfig = Bitmap.Config.ARGB_8888;

            Bitmap bmp = BitmapFactory.decodeStream(is, null, opts);
            ByteBuffer buf = ByteBuffer.allocateDirect(bmp.getRowBytes() * bmp.getHeight());
            bmp.copyPixelsToBuffer(buf);
            buf.rewind();

            Sprite ret = new Sprite();
            ret.upload(buf, bmp.getWidth(), bmp.getHeight(), FORMAT_RGBA);

            return ret;
        } catch (IOException e) {
            Engine.log("Failed to load sprite %s", fileName);

            throw new RuntimeException(e);
        }
    }

На этом реализация рендерера закончена. Да, все вот так просто :)
Переходим к двум остальным модулям — звук и ввод.

❯ Звук и ввод

Как я уже говорил, звук я решитл реализовать на базе уже существующей звуковой подсистемы Android. Ничего сложного в её реализацир нет, можно сказать, нам остаётся лишь написать обёртку, необходимую для работы. Изначально я написал собственный загрузчик wav-файлов и хотел использовать AudioTrack — класс для воспрозизведения PCM-звука напрямую, но мне не понравилось, что в нём нет разделения на источники звука и буферы, из-за чего каждый источник вынужден заниматься копированием PCM-потока в новый и новый буфер…


Полная реализация звукового потока выглядит так. И да, с SoundPool нет возможности получить позицию проигрывания звука или узнать, когда проигрывание закончилось. Увы.

public static class Instance {
        private AudioStream parent;
        private int id;

        Instance(AudioStream parent) {
            this.parent = parent;
        }

        public void play() {
            id = sharedPool.play(parent.streamId, Audio.MasterAudioLevel, Audio.MasterAudioLevel, 0, 0, 1.0f);
        }

        public void stop() {
            sharedPool.stop(id);
        }
    }

    private static SoundPool sharedPool;
    private int streamId;

    static {
        Engine.log("Allocating SoundPool");
        sharedPool = new SoundPool(255, AudioManager.STREAM_MUSIC, 0);
    }

    public AudioStream(int streamId) {
        this.streamId = streamId;
    }

    @Override
    protected void finalize() throws Throwable {
        sharedPool.unload(streamId);
        super.finalize();
    }

    public static AudioStream load(String fileName) {
        AssetManager assets = Engine.Current.MainActivity.getAssets();

        try {
            AssetFileDescriptor afd = assets.openFd("sounds/" + fileName);
            int streamId = sharedPool.load(afd, 0);

            return new AudioStream(streamId);
        } catch (IOException e) {
            Engine.log("Failed to load audio stream %s", fileName);

            return null;
        }
    }

Не забываем и про музыку:

private MediaPlayer mediaPlayer;
    private boolean ready;

    public MusicStream(MediaPlayer player) {
        mediaPlayer = player;
    }

    public void forceRelease() {
        if(mediaPlayer.isPlaying())
            mediaPlayer.stop();

        mediaPlayer.release();
    }

    public void play() {
        if(!mediaPlayer.isPlaying())
            mediaPlayer.start();
    }

    public void pause() {
        if(mediaPlayer.isPlaying())
            mediaPlayer.pause();
    }

    public void stop() {
        if(!mediaPlayer.isPlaying())
            mediaPlayer.stop();
    }

    public boolean isPlaying() {
        return mediaPlayer.isPlaying();
    }

    public void setLoop(boolean isLooping) {
        mediaPlayer.setLooping(isLooping);
    }

    public static MusicStream load(String fileName) {
        AssetManager assets = Engine.Current.MainActivity.getAssets();

        try {
            AssetFileDescriptor afd = assets.openFd("music/" + fileName);
            MediaPlayer player = new MediaPlayer();
            player.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
            player.setVolume(0.3f, 0.3f); // TODO: Move volume settings to Audio
            player.prepare();

            return new MusicStream(player);
        } catch (IOException e) {
            Engine.log("Failed to load audio stream %s", fileName);

            return null;
        }
    }

Да будет звук! Ну и про ввод не забываем:

public static final int TOUCH_IDLE = 0;
    public static final int TOUCH_PRESSED = 1;
    public static final int TOUCH_RELEASED = 2;

    public interface TextCallback {
        void onEnteredText(String str);
    }

    public static class TouchState {
        public boolean State;
        public int Id;
        public float X, Y;
    }

    public static int GAMEPAD_A = 0;
    public static int GAMEPAD_B = 1;
    public static int GAMEPAD_Y = 2;
    public static int GAMEPAD_X = 3;
    public static int GAMEPAD_LT = 4;
    public static int GAMEPAD_RT = 5;
    public static int GAMEPAD_DPAD_LEFT = 6;
    public static int GAMEPAD_DPAD_RIGHT = 7;
    public static int GAMEPAD_DPAD_UP = 8;
    public static int GAMEPAD_DPAD_DOWN = 9;
    public static int GAMEPAD_BUTTON_COUNT = 10;

    public static class GamepadState {
        public float AnalogX, AnalogY;
        public boolean[] Buttons;

        GamepadState() {
            Buttons = new boolean[GAMEPAD_BUTTON_COUNT];
        }
    }

    class TouchListener implements View.OnTouchListener {

        @Override
        public boolean onTouch(View view, MotionEvent motionEvent) {
            for(int i = 0; i < motionEvent.getPointerCount(); i++) {
                Touches[i].Id = motionEvent.getPointerId(i);

                // Convert from device-space to view-space.
                float xVal = motionEvent.getX() / Engine.Current.Graphics.DeviceWidth;
                float yVal = motionEvent.getY() / Engine.Current.Graphics.DeviceHeight;
                Touches[i].X = xVal * Engine.Current.Graphics.ViewWidth;
                Touches[i].Y = yVal * Engine.Current.Graphics.ViewHeight;

                if(motionEvent.getAction() == MotionEvent.ACTION_DOWN)
                    Touches[i].State = true;

                if(motionEvent.getAction() == MotionEvent.ACTION_UP)
                    Touches[i].State = false;
            }

            return true;
        }
    }

    public TouchState[] Touches;
    public GamepadState Gamepad;
    // Format - first int is KEYCODE mapped on Android, second is gamepad button
    private final int[] gamePadMapping =
            {
                    KeyEvent.KEYCODE_DPAD_CENTER, GAMEPAD_A,
                    KeyEvent.KEYCODE_BACK, GAMEPAD_B,
                    KeyEvent.KEYCODE_BUTTON_Y, GAMEPAD_Y,
                    KeyEvent.KEYCODE_BUTTON_X, GAMEPAD_X,
                    KeyEvent.KEYCODE_DPAD_UP, GAMEPAD_DPAD_UP,
                    KeyEvent.KEYCODE_DPAD_RIGHT, GAMEPAD_DPAD_RIGHT,
                    KeyEvent.KEYCODE_DPAD_LEFT, GAMEPAD_DPAD_LEFT,
                    KeyEvent.KEYCODE_DPAD_UP, GAMEPAD_DPAD_UP,
                    KeyEvent.KEYCODE_DPAD_DOWN, GAMEPAD_DPAD_DOWN
            };

    public Input() {
        Touches = new TouchState[5];

        for(int i = 0; i < Touches.length; i++)
            Touches[i] = new TouchState();

        Gamepad = new GamepadState();

        Engine.log("Initializing input subsystem...");
        Engine.Current.Graphics.GLView.setOnTouchListener(new TouchListener());
    }

    public int isTouchingZone(float x, float y, float w, float h) {
        boolean touching = false;

        for(int i = 0; i < Touches.length; i++) {
            touching = Touches[i].X > x && Touches[i].Y > y && Touches[i].X < x + w && Touches[i].Y < y + h;

            if(touching && Touches[i].State)
                return i;
        }

        return -1;
    }

    public boolean isAnyFingerInZone(float x, float y, float w, float h) {
        boolean touching = false;

        for(int i = 0; i < Touches.length; i++) {
            touching = Touches[i].X > x && Touches[i].Y > y && Touches[i].X < x + w && Touches[i].Y < y + h;

            if(touching && Touches[i].State)
                return true;
        }

        return false;
    }

    public void requestTextInput(String title, String target, TextCallback callback) {
        AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(Engine.Current.MainActivity);

        TextView text = new TextView(Engine.Current.MainActivity);
        EditText editor = new EditText(Engine.Current.MainActivity);

        text.setText(target + ":");
        editor.setLayoutParams(new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        dlgBuilder.setTitle(title);

        LinearLayout layout = new LinearLayout(Engine.Current.MainActivity);
        layout.addView(text);
        layout.addView(editor);
        layout.setOrientation(LinearLayout.VERTICAL);
        layout.setPadding(5, 5, 5, 5);
        dlgBuilder.setView(layout);
        dlgBuilder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                callback.onEnteredText(editor.getText().toString());
            }
        });

        Engine.Current.MainActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                dlgBuilder.show();
            }
        });
    }

Сама реализация джойстика крайне простая — запоминаем координаты, куда пользователь поставил палец и затем считаем дистанцию положения пальца относительно центральной точки, параллельно нормализовывая их относительно максимальной дистанции:

public class Joystick {
    private Sprite joySprite;

    public float VelocityX;
    public float VelocityY;

    public float OriginX, OriginY;
    private float fingerX, fingerY;
    private int joyFinger;

    public Joystick() {
        joySprite = Sprite.load("ui_button.png");

        OriginX = -999;
        OriginY = -999;
    }

    private float clamp(float a, float min, float max) {
        return a < min ? min : (a > max ? max : a);
    }

    public void update() {
        int finger = 0;

        if((finger = Engine.Current.Input.isTouchingZone(0, 0, Engine.Current.Graphics.ViewWidth, Engine.Current.Graphics.ViewHeight)) != -1) {
            if(OriginX == -999) {
                OriginX = Engine.Current.Input.Touches[finger].X;
                OriginY = Engine.Current.Input.Touches[finger].Y;
            }

            float xdiff = (Engine.Current.Input.Touches[finger].X - OriginX) / Engine.Current.Graphics.ViewWidth;
            float ydiff = (Engine.Current.Input.Touches[finger].Y - OriginY) / Engine.Current.Graphics.ViewHeight;

            VelocityX = clamp(xdiff / 0.2f, -1, 1);
            VelocityY = clamp(ydiff / 0.2f, -1, 1);
        } else {
            OriginX = -999;
            OriginY = -999;
        }
    }

    public void draw() {
        VelocityX = 0;
        VelocityY = 0;
    }
}

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

Основа для игры есть, теперь переходим к её реализации!

❯ Пишем игру

Писать игру я начал с создания первого уровня и реализации загрузчика уровней. В качестве редактора, я выбрал популярный и широко-известный TilEd — удобный редактор с возможностью экспорта карт в несколько разных форматов. Я лично выбрал Json, поскольку в Android уже есть удобный пакет для работы с этим форматом данных.

private void parseJson(String json) {
        try {
            JSONObject obj = new JSONObject(json);

            width = obj.getInt("width");
            height = obj.getInt("height");

            JSONArray jtileSet = obj.getJSONArray("tilesets").getJSONObject(0).getJSONArray("tiles");
            for(int i = 0; i < jtileSet.length(); i++) {
                JSONObject tile = jtileSet.getJSONObject(i);

                String name = tile.getString("image");
                name = name.substring(name.lastIndexOf("/") + 1);
                tileSet[tile.getInt("id")] = Sprite.load(name);
            }

            JSONArray layers = obj.getJSONArray("layers");

            this.tiles = new byte[width * height];
            Engine.log("Level size %d %d", width, height);

            for(int i = 0; i < layers.length(); i++) {
                JSONObject layer = layers.getJSONObject(i);
                boolean isTileData = layer.has("data");

                if(isTileData) {
                    JSONArray tiles = layer.getJSONArray("data");

                    Engine.log("Loading tile data");
                    for(int j = 0; j < tiles.length(); j++)
                        this.tiles[j] = (byte)(tiles.getInt(j) - 1);
                } else {
                    JSONArray objects = layer.getJSONArray("objects");

                    for(int j = 0; j < objects.length(); j++) {
                        JSONObject jobj = objects.getJSONObject(j);

                        Prop prop = new Prop();
                        prop.Sprite = tileSet[jobj.getInt("gid") - 1];
                        prop.Name = jobj.getString("name");
                        prop.X = (float)jobj.getDouble("x");
                        prop.Y = (float)jobj.getDouble("y");
                        prop.Visible = true;

                        String type = jobj.getString("type");
                        if(type.equals("invisible"))
                            prop.Visible = false;

                        props.add(prop);
                    }
                }
            }
        } catch (JSONException e) {
            e.printStackTrace(); // Level loading is unrecoverable error
            throw new RuntimeException(e);
        }
    }

Запекание батчей:

private void buildBatch() {
        batches = new HashMap<Sprite, Graphics2D.StaticBatch>();

        for(int i = 0; i < width; i++) {
            for(int j = 0; j < height; j++) {
                Sprite tile = tileSet[tiles[j * width + i]];

                if(!batches.containsKey(tile))
                    batches.put(tile, new Graphics2D.StaticBatch(tile, width * height));

                batches.get(tile).addInstance(i * 32, j * 32, Graphics2D.Color.White);
            }
        }

        for(Sprite spr : batches.keySet()) {
            batches.get(spr).prepare();
        }

        Engine.log("Generated %d batches", batches.size());
    }

Карта делится на 3 базовые понятия: тайлы — фон, с изображением травы/асфальта/земли и.т.п, пропы — статичные объекты по типу деревьев и кустов и сущности — объекты, участвующие в игровом процессе, т.е игрок, зомби и летящие пули. Система сущностей реализована в виде абстрактного базового класса, который реализовывает логику апдейтов, просчитывает Forward-вектор и выполняет другие необходимые задачи:

public abstract class Entity {

    public float X, Y;
    public float ForwardX, ForwardY; // Forward vector
    public float RightX, RightY;
    public float Rotation;
    public boolean IsVisible;

    public int DrawingOrder;

    public float distanceTo(float x, float y) {
        x = X - x;
        y = Y - y;

        return (float)Math.sqrt((x * x) + (y * y));
    }

    public boolean AABBTest(Entity ent, float myWidth, float myHeight, float width, float height) {
        return X < ent.X + width && Y < ent.Y + height && ent.X < X + myWidth && ent.Y < Y + myHeight;
    }

    public void recalculateForward() {
        ForwardX = (float)Math.sin(Math.toRadians(Rotation));
        ForwardY = -(float)Math.cos(Math.toRadians(Rotation));
    }

    public void update() {
        recalculateForward();
    }

    public void draw() {

    }
}

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

@Override
    public void update() {
        super.update();

        joyInput.update();

        float inpX = joyInput.VelocityX;
        float inpY = joyInput.VelocityY;

        if(Engine.Current.Input.Gamepad.Buttons[Input.GAMEPAD_DPAD_LEFT]) {
            inpX = -1;
            Rotation = 270;
        }

        if(Engine.Current.Input.Gamepad.Buttons[Input.GAMEPAD_DPAD_RIGHT]) {
            inpX = 1;
            Rotation = 90;
        }

        if(Engine.Current.Input.Gamepad.Buttons[Input.GAMEPAD_DPAD_DOWN]) {
            inpY = 1;
            Rotation = 180;
        }

        if(Engine.Current.Input.Gamepad.Buttons[Input.GAMEPAD_DPAD_UP]) {
            inpY = -1;
            Rotation = 0;
        }

        X += inpX * (WALK_SPEED * Engine.Current.DeltaTime);
        Y += inpY * (WALK_SPEED * Engine.Current.DeltaTime);

        Engine.Current.Graphics.Camera.X = X - (Engine.Current.Graphics.ViewWidth / 2);
        Engine.Current.Graphics.Camera.Y = Y - (Engine.Current.Graphics.ViewHeight / 2);

        int finger = 0;
        if((finger = Engine.Current.Input.isTouchingZone(0, 0, Engine.Current.Graphics.ViewWidth, Engine.Current.Graphics.ViewHeight)) != -1) {
            Input.TouchState state = Engine.Current.Input.Touches[finger];

            aimX = state.X;
            aimY = state.Y;

            // Convert player position from world-space, to screen-space
            float ptfX = (X - Engine.Current.Graphics.Camera.X) - state.X;
            float ptfY = (Y - Engine.Current.Graphics.Camera.Y) - state.Y;

            Rotation = (float)Math.toDegrees(Math.atan2(-ptfX, ptfY));
            recalculateForward();

            if(nextAttack < 0) {
                GunItem currGun = Guns.get(EquippedGun);
                currGun.Gun.FireEffect.createInstance().play();
                nextAttack = currGun.Gun.Speed;

                Bullet bullet = new Bullet();
                bullet.Speed = 15;
                bullet.LifeTime = 3.0f;
                bullet.Rotation = Rotation;
                bullet.Damage = currGun.Gun.Damage;

                float bullX = sprites[currGun.Gun.Sprite].Width / 2;
                float bullY = sprites[currGun.Gun.Sprite].Height / 2;
                float fwXFactor = ForwardX * 19;
                float fwYFactor = ForwardY * 19;

                bullet.X = X + bullX - (Bullet.Drawable.Width / 2) + fwXFactor;
                bullet.Y = Y + bullY - (Bullet.Drawable.Height / 2) + fwYFactor;

                Game.current.World.spawn(bullet);
            }
        }
        nextAttack -= Engine.Current.DeltaTime;
    }

Список доступных стволов хранится в статическом массиве GunDescription:

public static Gun[] GunDescription = {
            new Gun("Glock-18", Player.SPRITE_HANDGUN, 20.0f, 0.4f, 20, 90, "glock18.wav", "pistol.png", 1500),
            new Gun("UZI", Player.SPRITE_HANDGUN, 20.0f, 0.15f, 20, 90, "uzi.wav", "pistol.png", 1500),
            new Gun("Deagle", Player.SPRITE_HANDGUN, 100.0f, 0.7f, 20, 90, "deagle.wav", "pistol.png", 1500),
            new Gun("TOZ-34", Player.SPRITE_HANDGUN, 100.0f, 1.1f, 20, 90, "shotgun.wav", "pistol.png", 1500),
            new Gun("XM1014", Player.SPRITE_HANDGUN, 90.0f, 0.6f, 20, 90, "shotgun.wav", "pistol.png", 1500),
            new Gun("AK47", Player.SPRITE_HANDGUN, 40.0f, 1.1f, 20, 90, "ak47.wav", "pistol.png", 1500),
            new Gun("M4-A1", Player.SPRITE_HANDGUN, 90.0f, 0.6f, 20, 90, "m4.wav", "pistol.png", 1500),
            new Gun("MiniFGun", Player.SPRITE_HANDGUN, 30.0f, 0.15f, 20, 90, "minigun.wav", "pistol.png", 1500)
    };

Ну и не забываем про реализацию зомби. Она тоже очень простая: есть базовый класс Zombie, от которого наследуются все монстры и который реализует несколько необходимых методов — повернуться в сторону игрока, идти вперед и конечно же атака!

@Override
    public void update() {
        super.update();

        Player player = Game.current.World.Player;
        rotateTowardsEntity(player);

        if(distanceTo(player.X, player.Y) > 35)
            moveForward(WALK_SPEED * Engine.Current.DeltaTime);
    }

❯ Что у нас есть на данный момент?

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

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

❯ Заключение

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

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

---

Возможно, захочется почитать и это:

• ➤ Не дадим Windows Phone умереть! Как я написал свои клиенты VK, YouTube для Nokia Lumia? Сам себе экосистема
• ➤ Сам себе игровая консоль: превращаем планшет с нерабочим тачскрином в игровой девайс из 8 кнопок и микроконтроллера
• ➤ Чудовищное уравнение 45-ой степени, которое Франсуа Виет решил в 16 веке
• ➤ Запуск приложений на .NET в качестве службы на Linux-системе с systemd
• ➤ Программирование для Palm OS: что же там самое сложное?