Справочник Жаркова по проектированию и программированию искусственного интеллекта. Том 7: Программирование на Visual C# искусственного интеллекта. Издание 2

Валерий Алексеевич Жарков, 2023

В серии книг “Справочник Жаркова по проектированию и программированию искусственного интеллекта” в нескольких томах собрано лучшее программирование искусственного интеллекта (ИИ) в двух- и трёхмерных играх и приложениях, разработанных как автором, так и взятые из Интернета за многие годы и доработанные автором. Программирование ИИ на Visual C# написано в IX частях, которые разделены на два тома 7 и 8. В томе 7 дано. I. Краткие основы Visual C#. II. Учебное программирование игр и приложений с подвижными объектами. III. Программирование ИИ в играх в “Крестики-нолики”. IV. Программирование ИИ в спортивных играх на примере игры в теннис. V. Программирование ИИ в играх по сборке фигур из элементов одинакового цвета или одинаковой геометрии. VI. Распространение приложения. Даны полные тексты программ на VC# для Игрока с Компьютером, которые можно переписать на другой язык. Книги предназначены для желающих изучить программирование ИИ в играх и приложениях на базе VC# и других языков.

Часть II. Учебная методология программирования игр и приложений с подвижными объектами

Глава 4. Методика анимации и управления подвижными объектами

4.1. Методика добавления объекта в проект

Разработаем общую обучающую методику создания типичной и широко распространённой игры, когда в качестве летающих игровых объектов используются продукты питания, следуя статье с сайта microsoft.com: Rob Miles. Games Programming with Cheese: Part One. Так как эта статья написана по программированию игры на смартфоне и, к тому же, при помощи устаревшей версии Visual Studio, то автор данной книги переработал статью для программирования игры на настольном компьютере и, к тому же, при помощи новейшей версии Visual Studio.

Общие требования к программному обеспечению для разработки этой игры приведены выше. Методично и последовательно начнём решать типичные задачи (с подробными объяснениями) по созданию данной базовой учебной игры и всех подобных игр типа аркады (arcade).

Первым летающим объектом, используемом в игре, является, например, какой-либо продукт питания, например, маленький кусочек сыра (cheese). Так как на экране должно размещаться большое количество игровых объектов, то размер изображения сыра также должен быть небольшим, например, 25 x 32 пикселей. Если необходимо уменьшить объем файла любого изображения, то можно воспользоваться каким-либо графическим редактором, например, Paint, который поставляется с любой операционной системой Windows.

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

Создаём базовый учебный проект по обычной схеме: в VS в панели New Project в окне Project types выбираем тип проекта Visual C#, Windows, в окне Templates выделяем шаблон Templates, Visual C#, Windows Classic Desktop, Windows Forms App (.NET Framework), в окне Name записываем (или оставляем по умолчанию) имя проекта и щёлкаем OK. Важно отметить, что, так как, в отличие от приведённой выше статьи, имя этого проекта мы будем определять далее в коде программы, то в окне Name можно записать любое имя. Создаётся проект, появляется форма Form1 (рис. 4.1) в режиме проектирования. Проектируем (или оставляем по умолчанию) форму, как подробно описано в параграфе “Методика проектирования формы”. Например, если мы желаем изменить фон формы с серого на белый, то в панели Properties (для Form1) в свойстве BackColor устанавливаем значение Window.

Рис. 4.1. Форма. Рис. 4.2. Файл рисунка в SE (слева) и в Properties (справа).

Добавляем в проект (из отмеченной выше статьи или из Интернета) файл изображения сыра cheese.jpg по стандартной схеме, а именно: в меню Project выбираем Add Existing Item, в этой панели в окне “Files of type” выбираем “All Files”, в центральном окне находим и выделяем имя файла и щёлкаем кнопку Add (или дважды щёлкаем по имени файла).

В панели Solution Explorer мы увидим этот файл (рис. 4.2).

Теперь этот же файл cheese.jpg встраиваем в проект в виде ресурса по разработанной выше схеме, а именно: в панели Solution Explorer выделяем появившееся там имя файла, а в панели Properties (для данного файла) в свойстве Build Action (Действие при построении) вместо заданного по умолчанию значения Content (Содержание) или None выбираем значение Embedded Resource (Встроенный ресурс).

Для написания программы, в самом верху файла Form1.cs записываем пространство имён System.Reflection для управления классом Assembly:

using System.Reflection; //For the Assembly class.

В панели Properties (для Form1) на вкладке Events дважды щёлкаем по имени события Paint. Появившийся шаблон метода Form1_Paint после записи нашего кода принимает следующий вид.

Другие варианты вывода изображения, например, на элемент управления PictureBox и после щелчка по какому-либо элементу управления уже приводились ранее.

Листинг 4.1. Метод для построения изображения.

//We declare the object of class System.Drawing.Image

//for a product:

Image cheeseImage;

//We load into the project the image files according

//to such scheme:

//We create an object myAssembly of the Assembly class

//and appropriate to it

//the link to the executed assembly of our application:

static Assembly myAssembly = Assembly.GetExecutingAssembly();

//We create the myAssemblyName object of

//the System.Reflection.AssemblyName class and appropriate to

//it the assembly name, which consists of a project name,

//Version, Culture, PublicKeyToken:

static AssemblyName myAssemblyName = myAssembly.GetName();

//From the assembly name by means of the Name property

//we select a string project name:

static string myName_of_project = myAssemblyName.Name;

private void Form1_Paint(object sender, PaintEventArgs e)

{

//We load into object of the System.Drawing.Image class

//the image file of the set format, added to the project,

//by means of ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

//We draw the image on the Form1:

e.Graphics.DrawImage(cheeseImage, 10, 20);

}

Строим и запускаем программу на выполнение обычным образом:

Build, Build Selection; Debug, Start Without Debugging.

Появляется форма Form1 с изображением типа встроенного нами рисунка сыра cheese.jpg (рис. 4.1).

Верхний левый угол изображения по отношению к верхнему левому углу экрана (где находится начало координат) расположен в соответствии с заданными нами координатами в строке кода (e.Graphics.DrawImage(myBitmap, 10, 20);).

4.2. Методика анимации объекта

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

Следующий пример кода создаёт метод updatePositions, который перемещает сыр. На данной стадии проектирования сыр будет только двигаться вправо и вниз (по осям координат “x” и “y”). Таким образом, добавляем в данный (или новый) проект такой код.

Листинг 4.2. Изменение координат продукта.

//Current abscissa of an object:

int cx = 50;

//Current ordinate of an object:

int cy = 100;

private void updatePositions()

{

cx++; //or cx = cx + 1;

cy++; //or cy = cy + 1;

}

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

В процессе игры, для вызова метода updatePositions через одинаковые промежутки времени, целесообразно использовать таймер. С панели инструментов Toolbox размещаем на форме компонент Timer (Таймер). В панели Properties (для данного компонента Timer) в свойстве Enabled оставляем булево значение False, а свойству Interval задаём значение 40 (миллисекунд, что соответствует 25 кадрам в секунду по стандарту телевещания России; 1000 миллисекунд равно 1 секунде).

Важно отметить, что добавление в проект компонента Timer (Таймер) означает, что наша игра должна отключить таймер, когда игра находится в фоновом режиме, и включить таймер при активации игры. Именно поэтому в панели Properties (для данного компонента Timer) в свойстве Enabled мы оставили булево значение False.

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

//We turn on the timer:

timer1.Enabled = true;

Окончательно, код в теле метода Form1_Paint должен иметь такой вид.

Листинг 4.3. Метод для рисования изображения.

private void Form1_Paint(object sender, PaintEventArgs e)

{

//We load into object of the System.Drawing.Image class

//the image file of the set format, added to the project,

//by means of ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

//We draw the image on the Form1:

e.Graphics.DrawImage(cheeseImage, cx, cy);

//We turn on the timer:

timer1.Enabled = true;

}

Теперь всякий раз, когда вызывается метод Form1_Paint, программа рисует сыр на экране с соответствующими координатами cx и cy.

Дважды щёлкаем по значку для компонента Timer (ниже формы в режиме проектирования). Появляется шаблон метода timer1_Tick, который после записи нашего метода updatePositions и библиотечного метода Invalidate (или Refresh) для перерисовки изображения на экране принимает следующий вид.

Листинг 4.4. Метод для смены кадров на экране и перемещения фигуры.

private void timer1_Tick(object sender, EventArgs e)

{

//We call the method:

updatePositions();

//We redraw the screen:

Invalidate();

}

Строим и запускаем программу на выполнение обычным образом:

Build, Build Selection; Debug, Start Without Debugging.

В ответ Visual C# выводит форму Form1 в режиме выполнения, на которой изображение типа встроенного нами рисунка сыра cheese.jpg перемещается из верхнего левого угла по диагонали сверху вниз (в нижний правый угол) и скрывается (рис. 4.3).

Рис. 4.3. Объект перемещается по диагонали сверху вниз. Рис. 4.4. Отскок объекта.

Изображение объекта мерцает, что в дальнейшем будет исправлено применением двойной буферизации.

Таким образом, мы разработали методику анимации, по которой можно перемещать любые объекты на экране.

4.3. Методика проектирования отскока объекта от границы

Разработаем методику решения задачи по отскоку заданного нами объекта от заданных нами границ, например, от границ экрана. В качестве предмета и замкнутого пространства могут быть, например:

резиновый мяч, металлический или пластмассовый шар, который с большой силой бросил человек в каком-то помещении; предмет летает внутри помещения и отскакивает от пола, потолка и стен этого помещения;

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

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

Мы также введём большое число допущений, после чего задачу формулируем таким образом:

решаем плоскую задачу, т.е. предмет изображаем в виде его проекции на плоскость “x, y”; в качестве примера предмета выбираем кусочек сыра cheese.jpg, проекция которого на плоскость имеет вид прямоугольника;

на этой плоскости “x, y” замкнутое пространство изображаем в виде задаваемой нами замкнутой линии; в качестве примера замкнутой линии выбираем прямоугольник границы экрана;

предмет перемещается в этой плоскости “x, y” до столкновения с границей (линией), а после удара о границу должен отскочить от границы под определённым углом и перемещаться до следующего столкновения с границей, и так далее перемещаться и отражаться от линии;

принимаем обычное допущение, что до столкновения с границей предмет перемещается (летит) по прямой линии;

на основании допущения о том, что угол падения равен углу отражения, принимаем, что после столкновения с линией прямоугольника предмет отскакивает от этой линии под тем же углом; величину угла падения и угла отражения предмета от прямой линии принимаем равной 45 градусам;

перемещение предмета осуществляется поэтапно за интервал времени, который мы установим с помощью компонента Timer (Таймер);

интервал времени устанавливаем по значению свойства Interval компонента Timer; таким образом скорость перемещения объекта можно изменять за счёт изменения свойства Interval;

анимация является бесконечным (если в него не вмешиваться) нециклическим процессом; анимацию можно остановить на любом этапе и запустить вновь.

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

Таким образом, в данном проекте приведённый выше метод updatePositions заменяем на следующий.

Листинг 4.5. Отскок объекта от границ.

//Movement on an axis"x"to the right:

bool goingRight = true;

//Movement on an axis of"y"to the down:

bool goingDown = true;

private void updatePositions()

{

if (goingRight)

{

cx++;

}

else

{

cx–;

}

if ((cx + cheeseImage.Width) >= this.ClientSize.Width)

{

goingRight = false;

}

if (cx <= 0)

{

goingRight = true;

}

if (goingDown)

{

cy++;

}

else

{

cy–;

}

if ((cy + cheeseImage.Height) >= this.ClientSize.Height)

{

goingDown = false;

}

if (cy <= 0)

{

goingDown = true;

}

}

В этом коде видно, что координаты объекта “x, y” изменяются на величину +1, когда объект перемещается в положительном направлении осей “x, y” (вправо и вниз), и изменяются на величину — 1, когда объект перемещается в отрицательном направлении осей “x, y” (влево и вверх).

Код использует свойства ширины и высоты объекта (cheeseImage.Width и cheeseImage.Height) и экрана this.ClientSize.Width и this.ClientSize.Height). Вследствие этого программа будет нормально работать для любых размеров объекта и экрана.

В режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) мы видим, что на форме Form1 изображение типа встроенного нами рисунка сыра cheese.jpg перемещается по диагоналям в различных направлениях, отскакивая от границ экрана (рис. 4.4).

Методика приостановки и возобновления анимации уже была приведена выше.

4.4. Методика управления скоростью перемещения объекта и добавления звукового сигнала

Предыдущая программа довольно медленно перемещает объект по экрану. Если ширина экрана, например, 100 пикселей, то с частотой 25 кадров в секунду объект пересекает этот экран по горизонтальной прямой приблизительно за 4 секунды. Для управления скоростью перемещения объекта вместо предыдущего кода, в котором изображение перемещается на 1 пиксель через каждый Interval времени срабатывания таймера, можно изменить количество пикселей xSpeed, на которое объект перемещается через каждый Interval времени срабатывания таймера, как показано в следующем коде:

if (goingRight)

{

cx += xSpeed;

}

else

{

cx — = xSpeed;

}

Изменяя значение xSpeed, можно увеличить или уменьшить горизонтальную составляющую (по оси “x”) скорости объекта.

Следующий аналогичный код для координаты “y” позволяет изменять вертикальную составляющую скорости объекта:

if (goingDown)

{

cy += ySpeed;

}

else

{

cy — = ySpeed;

}

Увеличивать или уменьшать скорость перемещения объекта можно при помощи переменной change в следующем методе:

private void changeSpeed(int change)

{

xSpeed += change;

ySpeed += change;

}

В этом коде целочисленная переменная change задана в виде параметра метода changeSpeed. Положительное значение переменной change увеличивает перемещение изображения через каждый Interval времени срабатывания таймера и, тем самым, увеличивает скорость, отрицательное — уменьшает.

Если мы хотим подавать звуковой сигнал в различные моменты анимации, например, в момент каждого удара объекта о границу (внутри которой перемещается объект), то поступаем следующим образом. Согласно разработанной выше методике использования в нашем приложении метода (функции) из любого другого языка, на первом этапе необходимо создать ссылку на тот язык, например, на Visual Basic. Для этого в меню Project выбираем команду Add Reference, в панели Add Reference на вкладке (.NET) выбираем ссылку Microsoft.VisualBasic и щёлкаем кнопку OK. А в соответствующий метод, например, updatePositions записываем строку:

Microsoft.VisualBasic.Interaction.Beep();

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

Листинг 4.6. Отскок объекта от границ.

//The current increment of movement on an axis"x":

int xSpeed = 1;

//The current increment of movement on an axis"y":

int ySpeed = 1;

//The method for increase in traverse speed:

private void changeSpeed(int change)

{

xSpeed += change;

ySpeed += change;

}

//The method for change of coordinates of an object:

private void updatePositions()

{

if (goingRight)

{

cx += xSpeed;

}

else

{

cx — = xSpeed;

}

if ((cx + cheeseImage.Width) >= this.ClientSize.Width)

{

goingRight = false;

//At time of collision, the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cx <= 0)

{

goingRight = true;

//At time of collision, the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (goingDown)

{

cy += ySpeed;

}

else

{

cy — = ySpeed;

}

if ((cy + cheeseImage.Height) >= this.ClientSize.Height)

{

goingDown = false;

//At time of collision, the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cy <= 0)

{

goingDown = true;

//At time of collision, the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

}

Для управления скоростью перемещения объекта воспользуемся каким-либо элементом управления или компонентом, например, наиболее распространённым элементом Button (Кнопка). С панели инструментов Toolbox размещаем на форме две кнопки Button и в панели Propertiesс в свойстве Text для левой кнопки записываем “Быстрее”, а для правой кнопки — “Медленнее”. Отметим, что для этих целей вместо кнопок Button (чтобы не загромождать форму) можно использовать и клавиши клавиатуры по описанной далее методике.

В режиме редактирования дважды щёлкаем по левой кнопке “Быстрее”.

Появившийся шаблон метода после записи одной строки (changeSpeed(1);) принимает следующий вид.

Листинг 4.7. Метод для изменения скорости объекта.

private void button1_Click(object sender, EventArgs e)

{

changeSpeed(1);

}

Аналогично дважды щёлкаем по правой кнопке “Медленнее”. Появившийся шаблон метода после записи одной строки (changeSpeed(-1);) принимает следующий вид.

Листинг 4.8. Метод для изменения скорости объекта.

private void button2_Click(object sender, EventArgs e)

{

changeSpeed(-1);

}

В режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) мы видим, что на форме Form1 изображение типа встроенного нами рисунка сыра cheese.jpg перемещается в различных направлениях (рис. 4.5 и 4.6), отскакивая от границ экрана, а после выбора кнопок “Быстрее” или “Медленнее” этот объект перемещается соответственно быстрее или медленнее.

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

Рис. 4.5. Перемещение объекта. Рис. 4.6. Перемещение объекта.

4.5. Методика добавления нового объекта в игру

Теперь, когда программа может отображать кусочек сыра cheese.jpg в динамике, добавляем второй объект игры, который, как ракетка в теннисе отбивает мяч, будет отбивать этот кусочек сыра. В качестве такого большего по размерам объекта выбираем батон белого хлеба (с которым обычно едят сыр).

Добавляем в проект (из отмеченной выше статьи или из Интернета) файл изображения батона хлеба bread.jpg по стандартной схеме, а именно: в меню Project выбираем Add Existing Item, в этой панели в окне “Files of type” выбираем “All Files”, в центральном окне находим и выделяем имя файла и щёлкаем кнопку Add (или дважды щёлкаем по имени файла). В панели Solution Explorer мы увидим этот файл.

Теперь этот же файл bread.jpg встраиваем в проект в виде ресурса по разработанной выше схеме, а именно: в панели Solution Explorer выделяем появившееся там имя файла, а в панели Properties (для данного файла) в свойстве Build Action (Действие при построении) вместо заданного по умолчанию значения Content (Содержание) или None выбираем значение Embedded Resource (Встроенный ресурс).

Объявляем и инициализируем объект breadImage (класса Image) для загрузки в него изображения хлеба и две текущие координаты bx и by верхнего левого угла прямоугольника, описанного вокруг хлеба, в системе координат с началом в верхнем левом углу экрана. А приведённый выше код в теле метода Form1_Paint заменяем на тот, который дан на следующем листинге.

Листинг 4.9. Метод для рисования изображения.

//We declare the object of class System.Drawing.Image

//for the subject:

Image breadImage; // = null by default.

//Current abscissa of a subject:

int bx = 0;

//Current ordinate of a subject:

int by = 0;

private void Form1_Paint(object sender, PaintEventArgs e)

{

//We load into the object of class System.Drawing.Image

//the image file of the set format, added to the project,

//by means of the ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

breadImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"bread.JPG"));

//We draw the images on the Form1:

e.Graphics.DrawImage(cheeseImage, cx, cy);

e.Graphics.DrawImage(breadImage, bx, by);

//We turn on the timer:

timer1.Enabled = true;

}

В режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) мы видим, что на форме Form1 к перемещающемуся изображению сыра cheese.jpg добавилось изображение хлеба bread.jpg (в верхнем левом углу экрана), рис. 4.7.

Рис. 4.7. Подвижный сыр и неподвижный хлеб. Рис. 4.8. Сыр закрывает хлеб.

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

4.6. Методика устранения мерцания изображения при помощи двойной буферизации

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

Чтобы устранить мерцание изображения при помощи двойной буферизации, приведённый выше код в теле метода Form1_Paint заменяем на тот, который дан на следующем листинге (с подробными комментариями).

Листинг 4.10. Метод для рисования изображения.

//Buffer in the view of object of class Bitmap:

Bitmap backBuffer = null;

private void Form1_Paint(object sender, PaintEventArgs e)

{

//We load into object of class System.Drawing.Image

//the image file of the set format, added to the project,

//by means of ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

breadImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"bread.JPG"));

//If it is necessary, we create the new buffer:

if (backBuffer == null)

{

backBuffer = new Bitmap(this.ClientSize.Width,

this.ClientSize.Height);

}

//We create the object of class Graphics from the buffer:

using (Graphics g = Graphics.FromImage(backBuffer))

{

//We clear the form:

g.Clear(Color.White);

//We draw the image in the backBuffer buffer:

g.DrawImage(breadImage, bx, by);

g.DrawImage(cheeseImage, cx, cy);

}

//We draw the image on the Form1:

e.Graphics.DrawImage(backBuffer, 0, 0);

//We turn on the timer:

timer1.Enabled = true;

} //End of the method Form1_Paint.

Если мы сейчас запустим программу на выполнение, то увидим, что мерцание уменьшилось, но не исчезло совсем. Это объясняется тем, что при выполнении метода Form1_Paint операционная система Windows сначала заполняет экран цветом фона (background color), в нашем примере белым фоном (white), и только после этого поверх фона прорисовывает встроенные в программу изображения. Поэтому необходимо сделать так, чтобы операционная система Windows не изменяла фон. Для этого воспользуемся неоднократно применяемым и в наших предыдущих книгах, и в данной книге шаблоном метода OnPaintBackground, в тело которого мы ничего не будем записывать, как показано на следующем листинге.

Листинг 4.11. Метод OnPaintBackground.

protected override void OnPaintBackground(

System.Windows.Forms.PaintEventArgs e)

{

//We prohibit to redraw a background.

}

Этот метод OnPaintBackground следует записать непосредственно за методом Form1_Paint, естественно, в теле класса Form1.

Теперь в режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) подвижный сыр и неподвижный хлеб уже не мерцают, и мы решили данную задачу.

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

4.7. Методика управления направлением перемещения объекта при помощи элементов управления и мыши

Теперь программа должна перемещать батон хлеба таким образом, чтобы игрок мог отбивать хлебом сыр, как ракетка отбивает мяч в теннисе. Для перемещения объекта вверх (Up), вниз (Down), влево (Left) и вправо (Right) пользователь может использовать разнообразные элементы управления и компоненты с панели инструментов Toolbox, мышь, клавиатуру, джойстик и другие устройства. Для примера, размещаем на форме четыре кнопки Button с соответствующими заголовками в свойстве Text для перемещения хлеба Вверх, Вниз, Влево и Вправо (рис. 4.9). Перед размещёнием кнопок, для формы Form1 в панели Properties увеличиваем её размеры Size, например, до 384; 473.

Рис. 4.9. Подвижный сыр и управляемый нами хлеб. Рис. 4.10. Сыр закрывает хлеб.

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

В режиме проектирования дважды щёлкаем по каждой новой кнопке, а в панели Properties на вкладке Events дважды щёлкаем по имени события MouseMove. Появившиеся шаблоны методов для обработки этих событий после записи нашего кода принимают следующий вид.

Листинг 4.12. Методы для обработки событий.

private void button3_Click(object sender, EventArgs e)

{

//We move an object up:

by — = ySpeed;

}

private void button4_Click(object sender, EventArgs e)

{

//We move an object down:

by += ySpeed;

}

private void button5_Click(object sender, EventArgs e)

{

//We move an object to the left:

bx — = xSpeed;

}

private void button6_Click(object sender, EventArgs e)

{

//We move an object to the right:

bx += xSpeed;

}

private void Form1_MouseMove(object sender, MouseEventArgs e)

{

//We determine the coordinates of mouse pointer on form:

int mouseX = e.X;

int mouseY = e.Y;

//We set the coordinates of bread, equal to coordinates

//of mouse:

bx = mouseX;

by = mouseY;

}

Для удобства, задаём другие значения начальным координатам хлеба (например, int bx = 150; int by = 200;)

После запуска программы (Build, Build Selection; Debug, Start Without Debugging) сыр самостоятельно (без нашего участия) перемещается по экрану, отталкиваясь от границы со звуковым сигналом.

А после нажатий мышью четырёх кнопок Вверх, Вниз, Влево и Вправо мы можем перемещать батон хлеба в соответствующих четырёх направлениях по всему экрану (рис. 4.9).

На рис. 4.9 видно, что по умолчанию на форме выделена первая кнопка Button (на этой кнопке размещён фокус (Focus) программы), и поэтому данную кнопку мы можем нажать не только мышью, но и клавишей Enter, после чего скорость перемещения сыра возрастёт пропорционально количеству нажатий. Если мы желаем, чтобы по умолчанию была выделена другая, например, вторая кнопка Button, то в каком-либо методе, например, в методе Form1_Paint следует записать известный код (button2.Focus();). В режиме выполнения мы можем перемещать фокус, например, клавишами со стрелками или Tab на любую кнопку на форме, после чего воздействовать на эту кнопку клавишей Enter.

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

Следовательно, мы решили задачу по управлению объектом (в виде батона хлеба) при помощи элементов управления, например, кнопок Button и мыши.

Аналогично, как для события MouseMove, для управления игрой можно использовать методы-обработчики других событий мыши, которые имеются в панели Properties на вкладке Events для формы Form1 (рис. 4.11).

Рис. 4.11. События для управления игрой.

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

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

Таким образом, в этой главе мы разработали такие общие методики:

добавления объекта в проект;

анимации объекта;

проектирования отскока объекта от заданной нами границы, например, экрана;

управления скоростью перемещения объекта;

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

добавления нового объекта в игру (с использованием общего для всех объектов кода);

устранения мерцания изображения при помощи двойной буферизации;

управления направлением перемещения объекта с помощью клавиш.

Эти методики можно использовать при разработке самых разнообразных игр.

Глава 5. Методика обнаружения столкновений, программирования уничтожений летающих объектов и подсчёта очков

5.1. Определение прямоугольников, описанных вокруг объектов

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

Rob Miles. Games Programming with Cheese: Part Two.

Общие требования к программному обеспечению для разработки этой игры приведены выше.

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

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

Прямоугольник, описанный вокруг изображения батона хлеба bread.jpg, показан на рис. 5.1.

Рис. 5.1. Прямоугольник, описанный вокруг хлеба.

Ширина полей между объектом и описанным вокруг объекта прямоугольником должна быть сведена к минимуму, чтобы объект обязательно касался прямоугольника в как можно большем количестве точек и отрезков линий. Если начало прямоугольной системы координат “x, y” находится в верхнем левом углу экрана, то координаты верхней левой точки (bx, by) и нижней правой точки (bx + batWidth, by + batHeight) однозначно определяют данный прямоугольник на экране.

В среде выполнения.NET Framework (для настольных компьютеров) известна структура Rectangle (из пространства имён System.Drawing), у которой метод-конструктор Rectangle Constructor имеет несколько перегрузок. Наиболее применяемая перегрузка метода-конструктора Rectangle Constructor (которую далее и мы будем часто применять) с параметрами (Int32, Int32, Int32, Int32) структуры Rectangle на главных (в мире программирования) языках приведена в табл. 5.1.

Таблица 5.1.

Метод-конструктор Rectangle Constructor (Int32, Int32, Int32, Int32) структуры Rectangle.

Visual Basic (Declaration)

Public Sub New ( _

x As Integer, _

y As Integer, _

width As Integer, _

height As Integer _

Visual Basic (Usage))

Dim x As Integer

Dim y As Integer

Dim width As Integer

Dim height As Integer

Dim instance As New Rectangle(x, y, width, height)

C#

public Rectangle (

int x,

int y,

int width,

int height

)

C++

public:

Rectangle (

int x,

int y,

int width,

int height

)

J#

public Rectangle (

int x,

int y,

int width,

int height

)

JScript

public function Rectangle (

x: int,

y: int,

width: int,

height: int

)

В этом определении метода-конструктора Rectangle Constructor параметры переводятся так:

x — координата “x” верхнего левого угла прямоугольника;

y — координата “y” верхнего левого угла прямоугольника;

width — ширина (по оси “x”) прямоугольника;

height — высота (по оси “y”) прямоугольника.

Далее в нашей программе мы сначала объявим прямоугольники, описанные вокруг объектов, как новые переменные, например, так:

//The rectangle, described around the first object:

Rectangle cheeseRectangle;

//The rectangle, described around the second object:

Rectangle breadRectangle;

а затем в каком-либо методе создадим (при помощи ключевого слова new) и инициализируем эти объекты-прямоугольники, например, так:

cheeseRectangle = new Rectangle(cx, cy,

cheeseImage.Width, cheeseImage.Height);

breadRectangle = new Rectangle(bx, by,

breadImage.Width, breadImage.Height);

5.2. Обнаружение столкновения прямоугольников, описанных вокруг подвижных объектов

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

Когда далее при написании программы мы поставим оператор-точку “.” после какого-либо объекта структуры Rectangle, то увидим подсказку с двумя основными методами Intersect и IntersectsWith (рис. 5.2) для обнаружения пересечения двух прямоугольников.

Рис. 5.2. Подсказка с методами Intersect и IntersectsWith.

Определение для наиболее применяемого метода IntersectsWith (который далее и мы будем часто применять) с параметром (Rectangle rect) структуры Rectangle на главных (в мире программирования) языках приведено в табл. 5.2.

Таблица 5.2.

Определение метода Rectangle.IntersectsWith структуры Rectangle.

Visual Basic (Declaration)

Public Function IntersectsWith ( _

rect As Rectangle _

) As Boolean

Visual Basic (Usage)

Dim instance As Rectangle

Dim rect As Rectangle

Dim returnValue As Boolean

returnValue = instance.IntersectsWith(rect)

C#

public bool IntersectsWith (

Rectangle rect

)

C++

public:

bool IntersectsWith (

Rectangle rect

)

J#

public boolean IntersectsWith (

Rectangle rect

)

JScript

public function IntersectsWith (

rect: Rectangle

): Boolean

Этот метод IntersectsWith обнаруживает пересечение заданного нами первого прямоугольника со вторым прямоугольником, объявленного здесь как параметр (Rectangle rect).

Если метод определит, что ни одна точка одного прямоугольника не находится внутри другого прямоугольника, то метод возвращает булево значение False.

А если метод определит, что хотя бы одна точка одного прямоугольника находится внутри другого прямоугольника, то метод IntersectsWith возвращает булево значение True, и это значение применяется для изменения направления движения какого-либо прямоугольника на противоположное (чтобы уйти от дальнейшего пересечения), например, в таком коде:

//We check the collision of objects:

if (cheeseRectangle.IntersectsWith(breadRectangle))

{

//We change the direction of the movement to opposite:

goingDown =!goingDown;

//At the time of collision, we give a sound signal Beep:

Microsoft.VisualBasic.Interaction.Beep();

}

5.3. Код и выполнение программы

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

Листинг 5.1. Метод для рисования изображения.

//The rectangle, described around the first object:

Rectangle cheeseRectangle;

//The rectangle, described around the second object:

Rectangle breadRectangle;

private void Form1_Paint(object sender, PaintEventArgs e)

{

//We load into objects of class System.Drawing.Image

//the image files of the set format, added to the project

//by means of ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

breadImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"bread.JPG"));

//We initialize the rectangles, described around objects:

cheeseRectangle = new Rectangle(cx, cy,

cheeseImage.Width, cheeseImage.Height);

breadRectangle = new Rectangle(bx, by,

breadImage.Width, breadImage.Height);

//If it is necessary, we create the new buffer:

if (backBuffer == null)

{

backBuffer = new Bitmap(this.ClientSize.Width,

this.ClientSize.Height);

}

//We createobject of the Graphics class from the buffer:

using (Graphics g = Graphics.FromImage(backBuffer))

{

//We clear the form:

g.Clear(Color.White);

//We draw the image in backBuffer:

g.DrawImage(cheeseImage, cx, cy);

g.DrawImage(breadImage, bx, by);

}

//We draw the image on Form1:

e.Graphics.DrawImage(backBuffer, 0, 0);

//We turn on the timer:

timer1.Enabled = true;

} //End of the method Form1_Paint.

А вместо приведённого выше метода updatePositions для изменения координат записываем следующий метод, дополненный кодом для обнаружения столкновения объектов.

Листинг 5.2. Метод для изменения координат и обнаружения столкновения объектов.

private void updatePositions()

{

if (goingRight)

{

cx += xSpeed;

}

else

{

cx — = xSpeed;

}

if ((cx + cheeseImage.Width) >= this.Width)

{

goingRight = false;

//At the time of collision,

//the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cx <= 0)

{

goingRight = true;

//At the time of collision,

//the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (goingDown)

{

cy += ySpeed;

}

else

{

cy — = ySpeed;

}

//That cheese did not come for the button3.Location.Y:

if ((cy + cheeseImage.Height) >= button3.Location.Y)

{

goingDown = false;

//At the time of collision,

//the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cy <= 0)

{

goingDown = true;

//At the time of collision,

//the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

//We set to rectangles of coordinates of objects:

cheeseRectangle.X = cx;

cheeseRectangle.Y = cy;

breadRectangle.X = bx;

breadRectangle.Y = by;

//We check the collision of objects:

if (cheeseRectangle.IntersectsWith(breadRectangle))

{

//We change the direction of the movement to opposite:

goingDown =!goingDown;

//At the time of collision,

//the sound signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

} //End of the updatePositions method.

В режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) при помощи кнопок и мыши мы можем перемещать хлеб и этим хлебом, как ракеткой, отбивать сыр или вверх, или вниз (рис. 5.3). Напомним, что, так как угол падения сыра на хлеб равен 45 градусам, то и угол отражения сыра от хлеба (и от границ экрана) также равен 45 градусам.

5.4. Основные схемы столкновений и их реализация

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

Если мы оперируем с окружностями, описанными вокруг объектов, то возможны три основные схемы столкновений, показанные на рис. 5.4. В схемах 1 и 3 маленький круг ударяется о большой круг под углом 45 градусов и отражается под этим же углом и по этой же линии. В схеме 2 маленький круг ударяется о большой круг под углом 90 градусов и также вертикально отражается вверх.

Если же мы оперируем с прямоугольниками, описанными вокруг объектов, то возможны четыре основные схемы столкновений, показанные на рис. 5.5.

Рис. 5.3. Сыр отскочил от хлеба. Рис. 5.4. Три схемы столкновений.

Рис. 5.5. Четыре схемы столкновений.

В схемах 1 и 4 маленький прямоугольник ударяется о большой прямоугольник сбоку под углом 45 градусов и отражается под этим же углом и по этой же линии. В схемах 2 и 3 маленький прямоугольник падает на большой прямоугольник под углом 45 градусов, но отражается не по линии падения, а по линии отражения, перпендикулярной линии падения.

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

Листинг 5.3. Метод для изменения координат и обнаружения столкновения объектов.

private void updatePositions()

{

if (goingRight)

{

cx += xSpeed;

}

else

{

cx — = xSpeed;

}

if ((cx + cheeseImage.Width) >= this.Width)

{

goingRight = false;

//At the time of collision, the signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cx <= 0)

{

goingRight = true;

//At the time of collision, the signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (goingDown)

{

cy += ySpeed;

}

else

{

cy — = ySpeed;

}

//That cheese did not come for the button3.Location.Y:

if ((cy + cheeseImage.Height) >= button3.Location.Y)

{

goingDown = false;

//At the time of collision, the signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cy <= 0)

{

goingDown = true;

//At the time of collision, the signal Beep is given:

Microsoft.VisualBasic.Interaction.Beep();

}

//We check the collision of objects:

if (goingDown)

{

//If cheese moves down and there is the collision:

if (cheeseRectangle.IntersectsWith(breadRectangle))

{

//At the time of collision, the signal Beep

//is given:

Microsoft.VisualBasic.Interaction.Beep();

//We have the collision:

bool rightIn = breadRectangle.Contains(

cheeseRectangle.Right,

cheeseRectangle.Bottom);

bool leftIn = breadRectangle.Contains(

cheeseRectangle.Left,

cheeseRectangle.Bottom);

//types of collisions:

if (rightIn & leftIn)

{

//bounce up:

goingDown = false;

}

else

{

//bounce up:

goingDown = false;

//the bounces in horizontal direction:

if (rightIn)

{

goingRight = false;

}

if (leftIn)

{

goingRight = true;

}

}

}

}

} //End of the method updatePositions.

В режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) при помощи кнопок Button и мыши мы можем перемещать хлеб и этим хлебом, как ракеткой, отбивать сыр вверх не только верхней стороной прямоугольника (описанного вокруг объекта), как было в предыдущем коде, но теперь и боковыми сторонами этого прямоугольника. Однако мы можем отбивать, только если сыр перемещается сверху вниз.

5.5. Добавление новых объектов

Продолжаем усложнять игру за счёт добавления в неё новых объектов в виде продуктов питания, например, помидоров (tomatoes) в виде файла tomato.gif, рис. 5.6.

Рис. 5.6.

Помидор.

В начале игры несколько i-х помидоров в виде массива tomatoes[i] должны появиться в верхней части экрана в качестве мишеней (рис. 5.7), которые должны исчезать после попадания в них летающего сыра (рис. 5.8).

Попадание сыра в помидор определяется уже применяемым выше методом IntersectWith.

Исчезновение помидоров выполняется при помощи свойства visible, которому присваивается булево значение false (в коде: tomatoes[i].visible = false;).

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

Добавляем в наш проект (из отмеченной выше статьи или из Интернета) файл изображения помидора tomato.gif по стандартной схеме, а именно: в меню Project выбираем Add Existing Item, в этой панели в окне “Files of type” выбираем “All Files”, в центральном окне находим и выделяем имя файла и щёлкаем кнопку Add (или дважды щёлкаем по имени файла). В панели Solution Explorer мы увидим этот файл.

Теперь этот же файл tomato.gif встраиваем в проект в виде ресурса по разработанной выше схеме, а именно: в панели Solution Explorer выделяем появившееся там имя файла, а в панели Properties (для данного файла) в свойстве Build Action (Действие при построении) вместо заданного по умолчанию выбираем значение Embedded Resource (Встроенный ресурс).

Рис. 5.7. Помидоры — мишени. Рис. 5.8. Помидоры исчезают после попадания в них сыра.

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

Листинг 5.4. Переменные и методы для помидоров (tomatoes).

//We declare the object of the System.Drawing.Image class

//for product:

Image tomatoImage;

//Position and state of tomato

struct tomato

{

public Rectangle rectangle;

public bool visible;

}

// Spacing between tomatoes. Set once for the game

int tomatoSpacing = 4;

// Height, at which the tomatoes are drawn. Will change

// as the game progresses. Starts at the top.

int tomatoDrawHeight = 4;

// The number of tomatoes on the screen. Set at the start

// of the game by initialiseTomatoes.

int noOfTomatoes;

// Positions of the tomato targets.

tomato[] tomatoes;

// called once to set up all the tomatoes.

void initialiseTomatoes()

{

noOfTomatoes = (this.ClientSize.Width — tomatoSpacing) /

(tomatoImage.Width + tomatoSpacing);

// create an array to hold the tomato positions

tomatoes = new tomato[noOfTomatoes];

// x coordinate of each potato

int tomatoX = tomatoSpacing / 2;

for (int i = 0; i < tomatoes.Length; i++)

{

tomatoes[i].rectangle =

new Rectangle(tomatoX, tomatoDrawHeight,

tomatoImage.Width, tomatoImage.Height);

tomatoX = tomatoX + tomatoImage.Width + tomatoSpacing;

}

}

// Called to place a row of tomatoes.

private void placeTomatoes()

{

for (int i = 0; i < tomatoes.Length; i++)

{

tomatoes[i].rectangle.Y = tomatoDrawHeight;

tomatoes[i].visible = true;

}

}

Приведённый выше код в теле метода Form1_Paint заменяем на тот, который дан на следующем листинге.

Листинг 5.5. Метод для рисования изображения.

private void Form1_Paint(object sender, PaintEventArgs e)

{

//If it is necessary, we create the new buffer:

if (backBuffer == null)

{

backBuffer = new Bitmap(this.ClientSize.Width,

this.ClientSize.Height);

}

//We create a object of the Graphics class from the buffer:

using (Graphics g = Graphics.FromImage(backBuffer))

{

//We clear the form:

g.Clear(Color.White);

//We draw the image in the backBuffer:

g.DrawImage(cheeseImage, cx, cy);

g.DrawImage(breadImage, bx, by);

for (int i = 0; i < tomatoes.Length; i++)

{

if (tomatoes[i].visible)

{

g.DrawImage(tomatoImage,

tomatoes[i].rectangle.X,

tomatoes[i].rectangle.Y);

}

}

}

//We draw the image on the Form1:

e.Graphics.DrawImage(backBuffer, 0, 0);

} //End of the method Form1_Paint.

Добавление новых объектов в игру соответственно усложняет код. В панели Properties (для Form1) на вкладке Events дважды щёлкаем по имени события Load. Появившийся шаблон метода Form1_Load после записи нашего кода принимает следующий вид.

Листинг 5.6. Метод для рисования изображения.

private void Form1_Load(object sender, EventArgs e)

{

//We load into objects of class System.Drawing.Image

//the image files of the set format, added to the project,

//by means of ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

breadImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"bread.JPG"));

//We initialize the rectangles, described around objects:

cheeseRectangle = new Rectangle(cx, cy,

cheeseImage.Width, cheeseImage.Height);

breadRectangle = new Rectangle(bx, by,

breadImage.Width, breadImage.Height);

//We load the tomato:

tomatoImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"tomato.gif"));

//We initialize an array of tomatoes and rectangles:

initialiseTomatoes();

//We place the tomatoes in an upper part of the screen:

placeTomatoes();

//We turn on the timer:

timer1.Enabled = true;

}

И наконец, вместо приведённого выше метода updatePositions записываем следующий метод, дополненный новым кодом для изменения координат, обнаружения столкновений объектов и уничтожения помидоров.

Листинг 5.7. Метод для изменения координат и обнаружения столкновения объектов.

private void updatePositions()

{

if (goingRight)

{

cx += xSpeed;

}

else

{

cx — = xSpeed;

}

if ((cx + cheeseImage.Width) >= this.Width)

{

goingRight = false;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cx <= 0)

{

goingRight = true;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (goingDown)

{

cy += ySpeed;

}

else

{

cy — = ySpeed;

}

//That the cheese did not come for the button3.Location.Y:

if ((cy + cheeseImage.Height) >= button3.Location.Y)

{

goingDown = false;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cy <= 0)

{

goingDown = true;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

//We set to rectangles of coordinate of objects:

cheeseRectangle.X = cx;

cheeseRectangle.Y = cy;

breadRectangle.X = bx;

breadRectangle.Y = by;

//We check the collision of objects

//taking into account the tomatoes:

if (goingDown)

{

// only bounce if the cheese is going down

if (cheeseRectangle.IntersectsWith(breadRectangle))

{

//At the time of collision,

//the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

// we have a collision

bool rightIn = breadRectangle.Contains(

cheeseRectangle.Right,

cheeseRectangle.Bottom);

bool leftIn = breadRectangle.Contains(

cheeseRectangle.Left,

cheeseRectangle.Bottom);

// now deal with the bounce

if (rightIn & leftIn)

{

// bounce up

goingDown = false;

}

else

{

// bounce up

goingDown = false;

// now sort out horizontal bounce

if (rightIn)

{

goingRight = false;

}

if (leftIn)

{

goingRight = true;

}

}

}

}

else

{

// only destroy tomatoes of the cheese is going up

for (int i = 0; i < tomatoes.Length; i++)

{

if (!tomatoes[i].visible)

{

continue;

}

if (cheeseRectangle.IntersectsWith(

tomatoes[i].rectangle))

{

//At the time of collision,

//the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

// hide the tomato

tomatoes[i].visible = false;

// bounce down

goingDown = true;

// only destroy one at a time

break;

}

}

}

} //End of the method updatePositions.

В режиме выполнения (Build, Build Selection; Debug, Start Without Debugging) несколько i-х помидоров появляются в верхней части экрана в качестве мишеней (рис. 5.7), которые исчезают после попадания в них летающего сыра (рис. 5.8).

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

К разработке методики подсчёта очков в игре мы и приступаем.

5.6. Методика подсчёта очков в игре

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

Методика подсчёта очков (score) в игре подразумевает наличие в программе счётчика (scorer) очков и вывода очков на экран (например, методом DrawString) в строке:

g.DrawString(messageString, messageFont, messageBrush,

messageRectangle);

Видно, что в этом методе DrawString мы дожны определить параметры в виде шрифта messageFont, кисти messageBrush и зарезервированного прятоугольника для записи очков messageRectangle, причём в этот прямоугольник летающие объекты не должны залетать. На рис. 5.9 мы получили 20 очков за 2 сбитых помидора, а на 5.10 — 50 очков за 5 сбитых помидоров.

За каждый сбитый помидор мы можем начислить игроку любое количество очков, например, 10 очков в строке:

scoreValue = scoreValue + 10;

Новые очки сразу же выводятся на экран, информируя игрока.

Рис. 5.9. Получили 20 очков за 2 сбитых помидора. Рис. 5.10. Получили 50 очков.

Приступим к программной реализации методики подсчёта очков в игре в нашем базовом учебном проекте.

Сначала мы должны опустить ряд помидоров пониже, чтобы освободить место вверху для записи очков, поэтому вместо 4 записываем ординату, равную, например, 20:

int tomatoDrawHeight = 20;

В любом месте класса Form1 добавляем новые переменные для счётчика очков.

Листинг 5.8. Новые переменные.

// Font for score messages.

Font messageFont = null;

// Rectangle for score display.

Rectangle messageRectangle;

// Height of the score panel.

int scoreHeight = 20;

// Brush used to draw the messages.

SolidBrush messageBrush;

// The string, which is drawn as the user message.

string messageString ="Score: 0";

// Score in a game.

int scoreValue = 0;

Приведённый выше код в теле метода Form1_Paint заменяем на тот, который дан на следующем листинге.

Листинг 5.9. Метод для рисования изображения.

private void Form1_Paint(object sender, PaintEventArgs e)

{

//If the buffer empty, we create the new buffer:

if (backBuffer == null)

{

backBuffer = new Bitmap(this.ClientSize.Width,

this.ClientSize.Height);

}

//We create a object of class Graphics from the buffer:

using (Graphics g = Graphics.FromImage(backBuffer))

{

//We clear the form:

g.Clear(Color.White);

//We draw the images of objects in the backBuffer:

g.DrawImage(cheeseImage, cx, cy);

g.DrawImage(breadImage, bx, by);

for (int i = 0; i < tomatoes.Length; i++)

{

if (tomatoes[i].visible)

{

g.DrawImage(tomatoImage,

tomatoes[i].rectangle.X,

tomatoes[i].rectangle.Y);

}

}

//We write the player's points:

g.DrawString(messageString, messageFont, messageBrush,

messageRectangle);

}

//We draw the image on the Form1:

e.Graphics.DrawImage(backBuffer, 0, 0);

} //End of the method Form1_Paint.

Приведённый выше код в теле метода Form1_Load (для загрузки файлов изображений игровых объектов) заменяем на тот, который дан на следующем листинге.

Листинг 5.10. Метод для загрузки файлов изображений.

private void Form1_Load(object sender, EventArgs e)

{

//We load into objects of the System.Drawing.Image class

//the image files of the set format, added to the project,

//by means of ResourceStream:

cheeseImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"cheese.JPG"));

breadImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"bread.JPG"));

//We initialize the rectangles, described around objects:

cheeseRectangle = new Rectangle(cx, cy,

cheeseImage.Width, cheeseImage.Height);

breadRectangle = new Rectangle(bx, by,

breadImage.Width, breadImage.Height);

//We load the image file of a new object:

tomatoImage =

new Bitmap(myAssembly.GetManifestResourceStream(

myName_of_project +"."+"tomato.gif"));

//We initialize an array of new objects and rectangles,

//described around these objects:

initialiseTomatoes();

//We place new objects in an upper part of the screen:

placeTomatoes();

//We create and initialize a font for record of points:

messageFont = new Font(FontFamily.GenericSansSerif, 10,

FontStyle.Regular);

//We reserve a rectangle on the screen

//for record of points:

messageRectangle = new Rectangle(0, 0,

this.ClientSize.Width, scoreHeight);

//We set the color of a brush for record of points:

messageBrush = new SolidBrush(Color.Black);

//We turn on the timer:

timer1.Enabled = true;

} //End of the method Form1_Load.

И наконец, вместо приведённого выше метода updatePositions записываем следующий метод, дополненный новым кодом для изменения координат, обнаружения столкновений объектов, уничтожения помидоров и подсчёта очков.

Листинг 5.11. Метод для изменения координат и обнаружения столкновения объектов.

private void updatePositions()

{

if (goingRight)

{

cx += xSpeed;

}

else

{

cx — = xSpeed;

}

if ((cx + cheeseImage.Width) >= this.Width)

{

goingRight = false;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cx <= 0)

{

goingRight = true;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (goingDown)

{

cy += ySpeed;

}

else

{

cy — = ySpeed;

}

//That cheese did not come for the button3.Location.Y:

if ((cy + cheeseImage.Height) >= button3.Location.Y)

{

goingDown = false;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

if (cy <= 0)

{

goingDown = true;

//At the time of collision, the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

}

//We set to rectangles of coordinate of objects:

cheeseRectangle.X = cx;

cheeseRectangle.Y = cy;

breadRectangle.X = bx;

breadRectangle.Y = by;

// check for collisions.

if (goingDown)

{

// only bounce if the cheese is going down

if (cheeseRectangle.IntersectsWith(breadRectangle))

{

//At the time of collision,

//the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

// we have a collision

bool rightIn = breadRectangle.Contains(

cheeseRectangle.Right,

cheeseRectangle.Bottom);

bool leftIn = breadRectangle.Contains(

cheeseRectangle.Left,

cheeseRectangle.Bottom);

// now deal with the bounce

if (rightIn & leftIn)

{

// bounce up

goingDown = false;

}

else

{

// bounce up

goingDown = false;

// now sort out horizontal bounce

if (rightIn)

{

goingRight = false;

}

if (leftIn)

{

goingRight = true;

}

}

}

}

else

{

// only destroy tomatoes of the cheese is going up

for (int i = 0; i < tomatoes.Length; i++)

{

if (!tomatoes[i].visible)

{

continue;

}

if (cheeseRectangle.IntersectsWith(

tomatoes[i].rectangle))

{

//At the time of collision,

//the Beep signal is given:

Microsoft.VisualBasic.Interaction.Beep();

// hide the tomato

tomatoes[i].visible = false;

// bounce down

goingDown = true;

// update the score

scoreValue = scoreValue + 10;

messageString ="Points:"+ scoreValue;

// only destroy one at a time

Конец ознакомительного фрагмента.