Пишем движок игры под Android – tutorial часть 4 (слои и сцена)

Привет! Продолжаю писать наш игровой движок для Android.

Вот здесь мы вроде как разобрались со спрайтами.

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

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

package ru.davidmd.myengine;

import java.util.LinkedList;

import android.graphics.Paint;

/**
 * @author davidmd
 * @version 0.1 Слой на который можно добавлять объекты {@link mBasic}
 *          Используется в классе сцены {@link mScene}
 */
public class mLayer {
	LinkedList<mBasic> data = new LinkedList<mBasic>();

	/**
	 * номер слоя в стопке слоев на сцене
	 */
	int level;

	/**
	 * Кисть, которой должен отрисовываться слой
	 */
	public Paint p;

	private boolean processing=false;

	/**
	 * Конструктор принимает в качестве параметра номер слоя
	 *
	 * @param lev
	 *            номер слоя на сцене
	 */
	public mLayer(int lev) {
		processing = true;
		level = lev;
		p = new Paint();
		processing = false;
	}

	/**
	 * добавление на слой объектов
	 *
	 * @param item
	 *            - графический объект
	 */
	public void add(mBasic item) {
		processing = true;
		data.add(item);
		processing = false;
	}

	/**
	 * @return возвращает количество объектов на слое
	 */
	public int getSize() {
		return data.size();
	}

	/**
	 * Возвращает объект <b>mBasic</b> c номером <b>i</b>
	 *
	 * @param i
	 *            номер объекта
	 * @return объект со слоя с номером <b>i</b>
	 */
	public mBasic get(int i) {
		return data.get(i);
	}

	/**
	 * Удаляет объект с номером i со слоя
	 *
	 * @param i
	 */
	public void delete(int i) {
		processing = true;
		data.remove(i);
		processing = false;
	}

	/**
	 * Очищает текущий солой
	 */
	public void clear() {
		processing = true;
		data.clear();
		processing = false;
	}

	/**
	 * обновляет все объекты на слое
	 */
	public void update() {
		processing = true;
		for (mBasic a : data) {
			if (a != null)
				a.update();
		}
		processing = false;
	}

	/**
	 * Изменение всех спрайтов на сцене
	 * @param newx - множитель ширины
	 * @param newy - множитель высоты
	 */
	public void resize(float newx, float newy)
	{
		processing = true;
		for (mBasic a: data){
			if (a!=null&&a.type==mBasic.TYPE_SIMPLESPRITE)
			{
				((mSimpleSprite)a).resize(newx, newy);
			}
		}
		processing = false;
	}

	/**
	 * выбирает первый объект на слое, в который попадает точка с кооординатами
	 * (f,g)
	 *
	 * @param f
	 *            координата по x
	 * @param g
	 *            координата по y
	 * @return объект со слоя
	 */
	public mBasic select(float f, float g) {
		mBasic tmp = null;
		for (int i = 0; i < data.size(); i++) {
			if (data.get(i) != null && data.get(i).isSelected(f, g)) {
				tmp = data.get(i);
				break;
			}
		}
		return tmp;
	}

	public boolean isProcessing() {
		return processing;
	}
}

Класс построен с использованием стандартного LinkedList. То есть связного списка. Вообще-то говорят, что работа с объектами подобного рода (LinkedList, ArrayList, Vector) значительно замедляет скорость выполнения кода на любой Java машине и Android здесь не исключение. Однако поскольку динамических массивов похожих например на паскалевские в Java как-то совсем нет, работа с указателями напрямую здесь тоже оказывается табу (меня это в свое время сильно удивило), то другого выхода я не вижу. Разве что попробовать реализовать свой собственный динамический массив куцыми средствами, которые дает нам Java. Но поскольку такой код вряд ли будет работать быстро, было решено использовать именно этот класс, несмотря на то что он не является потоко-безопасным (т.е. если мы одновременно попытаемся выполнить какие-то действия с этим объектом из разных потоков никто не знает к чему это может привести 🙂 Поэтому не стоит забывать об этом при реализации).

Итак, что у нас тут имеется? А имеется, собственно, следующее: сам связаный список data элементами которого являются объекты экземпляры mBasic (а значит и всех унаследованных от него классов). Затем идет переменная layer — это просто номер слоя на сцене. И для большей гибкости у каждого слоя есть кисть p, которой этот слой впоследствии будет отрисовываться. Также на всякий случай есть логическая переменная processing — которая есть ни что иное, как флаг, говорящий о том, что в список data вносятся какие-то изменения (незабываем про его потоко-небезопасность). За состоянием этого флага следить будем самостоятельно. То есть в каждом методе где мы что-то добавляем в список или удаляем из него, первой строкой в этот флаг записывается истина, а последней строкой — ложь. Ну например в конструкторе public mLayer(int lev) именно так и происходит. Помимо этого реализованы методы для добавления объекта на сцену, удаления объекта со сцены, получения количества объектов на сцене и очистки всей сцены.

Метод update() вызывает одноименный метод для всех объектов на сцене, а метод resize() изменяет размер всех спрайтов на ней (кстати не плохо бы сделать чтоб изменялись размеры всех объектов в принципе). Ну и последнее, что у нас здесь есть важного — это метод select(float x, float y) — который возвращает первый объект в который попадает точка с координатами (x,y).

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

package ru.davidmd.myengine;

/**
 * @author davidmd
 * @version 0.1 Сцена Набор слоев на каждый из которых можно добавлять
 *          графические примитивы При этом имеет активный слой с которым счас
 *          ведется работа и пассивные на которые можно переключиться
 */
public class mScene {

	/**
	 * Массив слоев на сцене
	 */
	mLayer[] layers;

	/**
	 * номер текущего слоя
	 */
	private int curLay;

	public static final int ORIENTATION_VERT=0;
	public static final int ORIENTATION_HOR=1;

	private int orient;
	/**
	 * Количество слоев на сцене
	 */
	private int layCount;

	/**
	 * Верхний слой на сцене
	 */
	public int TopLay;

	/**
	 * нижний слой на сцене
	 */
	public int BotLay = 0;

	/**
	 * высота и ширина сцены
	 */
	public int width, height;

	/**
	 * Конструктор Создание новой сцены
	 *
	 * @param width
	 *            - ширина
	 * @param height
	 *            - высота
	 * @param layerCount
	 *            - количество слоев
	 */
	public mScene(int width, int height, int layerCount) {
		this.width = width;
		this.height = height;
		if (this.width>this.height){orient=mScene.ORIENTATION_HOR;}
		else
		{orient = mScene.ORIENTATION_VERT;}
		layers = new mLayer[layerCount];
		curLay = 0;
		TopLay = layerCount - 1;
		for (int i = BotLay; i < layerCount; i++) {
			layers[i] = new mLayer(i);
		}
		layCount = layerCount;
	}

	/**
	 * Установить новую ширину и высоту сцены
	 *
	 * @param w
	 *            - новая ширина
	 * @param h
	 *            - новая высота
	 */
	public void setWH(int w, int h) {
		this.width = w;
		this.height = h;
	}

	/**
	 * Установить текущий слой
	 *
	 * @param i
	 */
	public void setCurLay(int i) {
		if (i <= TopLay)
			curLay = i;
		else
			curLay = TopLay;
	}

	/**
	 * Добавить объект на текущий слой сцены
	 *
	 * @param item
	 */
	public void addItem(mBasic item) {
		layers[curLay].add(item);
	}

	/**
	 * @return Возвращает номер текущего слоя
	 */
	public int getCurlayNum() {
		return this.curLay;
	}

	/**
	 * @return возвращает текущий слой
	 */
	public mLayer getCurLay() {
		return layers[this.curLay];
	}

	/**
	 * Очищает текущий слой
	 */
	public void clear() {
		this.layers[this.curLay].clear();
	}

	/**
	 * @return возвращает количество слоев на сцене
	 */
	public int getLayCount() {
		return layCount;
	}

	/**
	 * удаляет с текущего слоя объект с номером i
	 *
	 * @param i
	 */
	public void delete(int i) {
		this.layers[this.curLay].delete(i);
	}

	/**
	 * пзменение размера всех спрайтов на сцене
	 * @param newx - множитель по ширине
	 * @param newy - множитель по высоте
	 */
	public void resize(float newx, float newy)
	{
		for (mLayer a: layers)
		{
			a.resize(newx, newy);
		}
	}

	public mLayer getLayerByNum(int num)
	{
		if (num<this.layCount)
		{
			return layers[num];
		}
		return null;
	}

	/**
	 * @return Возвращает ориентацию экрана
	 * 1 - если горизонтальная
	 * 0 - если вертикальная
	 * ориетация расчитывается исходя из того
	 * что больше высота или ширина сцены
	 */
	public int getOrient() {
		return orient;
	}

	/**
	 * @return возвращает ширину сцены в пиксеах
	 */
	public int getWidth() {
		return width;
	}

	/**
	 * @return Возвращает высоту сцены в пикселах
	 */
	public int getHeight() {
		return height;
	}

	/**
	 * Выбирает обхъект c текущего слоя сцены который содержит точку с
	 * координатами f и g
	 *
	 * @see ru.davidmd.myengine.mLayer
	 * @param f
	 *            - координата по
	 * @param g
	 *            - координата по
	 * @return возвращает объект или null если подходящего объекта на слое не
	 *         нашлось
	 */
	public mBasic selectSprite(float f, float g) {
		mBasic sel = null;
		sel = this.layers[curLay].select(f, g);
		return sel;
	}

	/**
	 * Обновляет все соержимое сцены
	 */
	public void update() {
		for (mLayer l : layers) {
			l.update();
		}
	}
}

Как уже можно было догадаться количество слоев на сцене задается во время ее создания. Также во время создания задается ширина и высота сцены в пикселах это width и height. Как их использовать я пока не понял, но пусть на всякий случай будут :-). Сами слои — это массив layers. переменная curLay — это текущий слой, а orient — ориентация экрана (тоже задел на будущее). Переменные TopLay и BotLay — просто номера самого верхнего и самого нижнего слоя.

Теперь посмотрим на методы.  Ну во-первых метод добавления элемента на сцену public void addItem(mBasic item) — занимается тем, что добавляет элементы на текущий слой. Метод setCurLay(int i) устанавливает текущий слой. getCurlayNum() — возвращает номер текущего слоя а getCurLay() — сам этот слой. Также  присутствуют и другие методы.

Думаю код достаточно прозрачен и разобраться что к чему труда не составит 🙂

Если появились какие-то вопросы,  пишите в комментах. Код классов можно скачать тут myengine. Всем пока! Пошел я спать 🙂