В самом начале исходного кода класса Game1 происходит объявление гло-
бальных объектов и добавляются две новые строки кода.

int screenWidth, screenHeight;
Random rand = new Random();

В первой строке кода мы создаем две дополнительные переменные, которые впоследствии будут содержать соответственно ширину и высоту разрешения экрана, установленную нами в конструкторе класса Game1.

graphics.PreferredBackBufferWidth = 1280;
graphics.PreferredBackBufferHeight = 720;
screenWidth = graphics.PreferredBackBufferWidth;
screenHeight = graphics.PreferredBackBufferHeight;

В свою очередь, системный класс Random позволяет в программах генерировать для заданной переменной какое-то новое случайное значение. В состав класса входит метод Next(), который при каждом новом вызове формирует последовательность случайных чисел. Метод Next() имеет три следующие модификации:
* Random.Next() – возвращает положительное случайное число;
* Random.Next(int32) – возвращает положительное случайное число, где единственный параметр метода – это верхняя граница, или максимальное число, выше которого не может быть сгенерировано новое значение.
Например, если вызвать метод вот так: Next(20), то сгенерированное число не будет выходить из диапазона от 0 до 20;
* Random.Next(int32, int32) – этот вид метода с двумя параметрами позволяет задавать диапазон от выбранного минимального числа до максимального числа. Например, вызов метода со значениями Next(15, 20) задаст диапазон для случайного числа в пределах от 15 до 20.
Класс Random и метод Next() нам будут необходимы для задания новой позиции на экране телевизора в методе MoveSprite() класса Game1. Это новый метод, который добавляется в текущий проект и выглядит следующим образом:

public void MoveSprite()
{
sprite.spritePosition += sprite.speedSprite;
if (sprite.spritePosition.Y > screenHeight)
{
sprite.spritePosition = new Vector2(rand.Next(50, screenWidth -
sprite.spriteTexture.Width / 12 - 50), -200);
}
}

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

sprite.spritePosition.X += sprite.speedSprite.X; // где скорость по X равна 0
sprite.spritePosition.Y += sprite.speedSprite.Y; // где скорость по Y равна 6

Такая запись также может иметь место в исходном коде метода MoveSprite(), но представленный первый вариант несколько профессиональнее и быстрее работает.
Оставшиеся три строки кода метода MoveSprite() обрабатывают ситуацию выхода спрайта за пределы экрана с нижней стороны экрана. Как только позиция спрайта оказывается больше, чем максимальный размер высоты экрана, то в исходном коде метода MoveSprite() происходит вход в конструкцию if/else, где определяется новая точка вывода спрайта на экран.

sprite.spritePosition = new Vector2(rand.Next(50, screenWidth -
sprite.spriteTexture.Width / 12 - 50), -200);

Здесь мы используем метод Next(), с помощью которого при определении координаты по оси X задаем случайное значение в диапазоне от 50 пикселей до screenWidth - sprite.spriteTexture.Width / 12 – 50 или в числовом эквиваленте 1280 - один фрейм анимационной последовательности – 50 пикселей от кромки экрана для красоты, что позволяет нам при каждом новом определении места вывода спрайта на экране по оси X задавать новое значение в пределах видимой области экрана.
С выбором случайных значений для новой позиции спрайта игрок не будет знать, в каком месте должен выводиться спрайт на экран, и впоследствии не сможет приспособиться к вашей игре. Новое место будет всегда неожиданным как для игрока, так, собственно, и для вас, потому что используется метод Next() с двумя параметрами, задающими определенный диапазон значений. Дополнительные 50 пикселей, которые мы отняли от ширины дисплея с двух сторон, необходимы просто для красоты, дабы спрайты не рисовались вплотную к краям экрана телевизора.
Что касается задания координаты по оси Y, то она, как вы заметили, отрицательна. Это позволяет рисовать спрайт в верхней части экрана за пределами видимости.
После чего спрайт мы перемещаем вниз (рис. 8.2). Таким образом достигается эффект плавного появления, или выезда спрайта из верхней части экрана и всего игрового пространства. Это красиво, эффектно, и если этого не делать и рисовать спрайт в положительных значениях оси Y, то объекты будут появляться резко и как бы ни с того ни с сего. Так делать нельзя, по крайней мере в нашей игре точно. В других играх могут быть свои задачи, поэтому этот подход имеет право на жизнь.
После создания метода MoveSprite() необходимо поместить вызов этого метода в метод Update(GameTime gameTime) класса Game1. Тогда на каждой итерации игрового цикла будет происходить вызов метода MoveSprite() и соответственно обновление состояния спрайта, а также обработка ситуации с выходом спрайта из зоны видимости. Исходный код проекта вы найдете на компактдиске в папке Code\Chapter8\MoveSprite, а мы переходим к рассмотрению следующего проекта MoveSpriteArray.

Рис. 8.2. Назначение спрайту новой позиции в игровом пространстве

Sprite[] sprite = new Sprite[5];

Здесь мы объявляем массив данных, исчисляемый пятью спрайтами. Все эти пять спрайтов, а точнее каждый из спрайтов будет загружать в игру свое уникальное изображение и представлять тот или иной объект. Каждый спрайт использует анимационную последовательность для создания динамики в игре, посмотрите на рис. 8.3, где представлены пять изображений, загружаемых в игру.
Все изображения, загружаемые в игру, размещаются в рабочем каталоге проекта в папке Content\Textures. Не забывайте, что все пять рисунков необходимо явно добавить в проект посредством команд Add -> Exiting Item, как мы это делали в предыдущих главах.
Далее в конструкторе класса Game1 происходит создание пяти объектов. Для этих целей используется обычный цикл for.

for (int i = 0; sprite.Length > i; i++)
{
sprite[i] = new Sprite(12, 10);
}

Рис. 8.3. Изображения, загружаемые в игру

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

sprite[0] = new Sprite(5, 3);
sprite[1] = new Sprite(8, 2);
sprite[2] = new Sprite(2, 2);
sprite[3] = new Sprite(3, 1);
sprite[4] = new Sprite(15, 2);

После создания массива данных переходим к методу LoadGraphicsContent() и к загрузке в массив данных графических изображений.

sprite[0].Load(content, «Content\\Textures\\0»);
sprite[1].Load(content, «Content\\Textures\\1»);
sprite[2].Load(content, «Content\\Textures\\2»);
sprite[3].Load(content, «Content\\Textures\\3»);
sprite[4].Load(content, «Content\\Textures\\4»);

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

protected override void Initialize()
{
j = 0;
for (int i = 0; sprite.Length > i; i++)
{
sprite[i].spritePosition = new Vector2(rand.Next(10, screenWidth - 150),
j = j - 300);
}
base.Initialize();
}

Для инициализации используется цикл. В качестве координаты по оси X для каждого спрайта применяется механизм случайного выбора позиции по ширине игровой области экрана. Этот механизм мы подробно рассмотрели в предыдущем проекте. А вот установка точки отсчета по оси Y проходит в несколько другом ключе с использованием переменной j = j - 300.
Здесь мы используем промежуточную переменную j, которая инициализируется нулевым значением. На каждой итерации цикла значение этой переменной уменьшается на 300 пикселей, что позволяет установить все спрайты как бы друг за другом на расстоянии 300 пикселей, и они не накладываются один на другой (рис. 8.4). Этот простой алгоритм позволяет нам избежать наложений спрайтов друг на друга в начальной стадии инициализации игры.
Далее в методе MoveSprite() переделываем код для движения уже массива объектов, а не одного спрайта.

public void MoveSprite()
{
for (int i = 0; sprite.Length > i; i++)
{
sprite[i].spritePosition += sprite[i].speedSprite;
if (sprite[i].spritePosition.Y > screenHeight)
{
sprite[i].spritePosition = new Vector2(rand.Next(50,
screenWidth -
sprite[i].spriteTexture.Width / 12 - 50), -500);
}
}
}

Рис. 8.4. Установка спрайтов на игровые позиции в момент первого запуска игры

Обработка ситуации с выходом спрайта из зоны видимости реализована, как и в предыдущем проекте, но по оси Y задается значение в –500 пикселей. Делается это для того, чтобы уже исчезнувшие с экрана спрайты ставились на новые позиции повыше (или подальше) и дали возможность пройти всем предыдущим спрайтам, еще не достигнувшим конца экрана.
Затем в методе Update() класса Game1 мы вызываем метод UpdateFrame() класса Sprite для обновления анимационной последовательности спрайтов и метод MoveSprite() для движения спрайтов по экрану.

///