Другие возможности
Другие возможности
Существует несколько способов сделать нашу игру более интересной. Цвета могут быть не произвольными, а обозначать определенное количество очков. Например, красные шары могут стоить 100 очков, синие - 50 и т.д. От цвета, в свою очередь, может зависеть скорость и высота полета шара. При этом чем выше и быстрее летит шар, тем больше его ценность.
Вы можете вообще отказаться от использования шаров. В сущности данная игра напоминает игры наподобие "Sea Wolf", задачей которых является поражение самолетов, или игры про космических пришельцев. Все, что требуется, - это заменить графику.
Другие возможности
Другие возможности
Как и предыдущую игру этой главы, только что рассмотренную можно усовершенствовать различными способами, например можно добавлять очки за шары, летящие выше и быстрее. Неплохим вариантом будет создание на ее основе игры, где в качестве целей будут использоваться самолеты. Оружие, из которого ведется обстрел, обычно в таких играх неподвижно, но может стрелять под разными углами.
Другие возможности
Другие возможности
Чтобы сделать игру труднее, вы можете ускорить движение захватчиков. Сначала попробуйте увеличить расстояние, на которое они падают каждый раз. Также можно увеличить скорость, с которой они движутся из стороны в сторону.
Если вы хотите добавить в игру уровней, то можете создать переменную startSpeed, которая начинается со значения 3. Задайте эту скорость функции balloonDirection каждого шарика вместо жестко заданного "3". Пусть теперь после того, как все шарики выбиты, игрок переходит к экрану "level over". Когда он нажимает кнопку "play next level", startSpeed увеличивается, и ролик отправляется к кадру "play", где шарики появляются с новой, более высокой скоростью.
Игра "Прицелься и выстрели" напоминает
Рисунок 10.4 Игра "Прицелься и выстрели" напоминает игру "Стрельба по шарам", однако в нее были добавлены новые возможности
К сведению
К сведению
Нажатие клавиши пробела контролируется кнопкой. В нашем примере она расположена за пределами рабочего поля, в левом верхнем углу экрана и визуально представляет собой надпись "button". Кнопке назначен следующий код:
on (keyPress "") {
_root.shootBullet() ;
}
На первый взгляд не ясно, почему используется клавиша пробела, а не проверка Key. isDown, осуществляемая функцией moveFox. Функция Key.isDown проверяет, нажата ли клавиша во время определенного промежутка времени. В нашем примере нажатие осуществляется один раз в каждом кадре. Если игрок быстро нажмет на клавишу, это событие может произойти между проверками Key. isDown. Программа не увидит, что клавиша нажата, и выстрела не произойдет. Использование кнопки гарантирует, что нажатие клавиши будет замечено и обработано.
Скорость воспроизведения ролика составляет 30 кадров в секунду, Благодаря этому анимация воспроизводится более плавно. Изменив скорость воспроизведения ролика, вам, может быть, придется изменить скорость перемещения лисы, шаров и снарядов. В противном случае скорость игры может не соответствовать вашим ожиданиям.К сведению
К сведению
Так как пули в данной игре могут разлетаться в разные стороны, мы поменяли изображение пули в клипе, теперь она напоминает не короткую линию, а скорее небольшую точку.
К сведению
К сведению
Как и в исходной игре этой главы, здесь есть вводный и заключительный кадры. Я в обоих играх использую одинаковые кадры вне зависимости от того, выиграл игрок или проиграл. Вы можете сделать два разных кадра с соответствующим текстом в каждом.
Лиса идет влево и всегда готова выстрелить из соломинки
Рисунок 10.2 Лиса идет влево и всегда готова выстрелить из соломинки

Клип, соответствующий воздушному шару, также состоит из нескольких кадров. Первый кадр содержит изображение обычного шара. Остальные кадры воспроизводят анимацию лопающегося шара. Воспроизведение этой короткой анимации задается при попадании в шар. На Рисунок 10.3 показан единственный кадр анимации ролика, возможно, вы захотите изобразить взрыв более подробно.
Лиса стреляет по пролетающим воздушным
Рисунок 10.1 Лиса стреляет по пролетающим воздушным шарам из соломинки
Подготовка ролика
Подготовка ролика
В ролике Balloonshoot.fla клип лисы содержит кадр с меткой "stand" и анимационную последовательность, помеченную "walk". Анимация изображает лису, перемещающуюся влево (Рисунок 10.2), однако при помощи Action-Script вы можете повернуть лису в другую сторону, не создавая отдельной анимации. Главное условие: соломинка должна занимать во всех кадрах одно и то же положение относительно центральной точки клипа.
Подготовка ролика
Подготовка ролика
Основное отличие данной игры от предыдущей состоит в том, что соломинка представляет собой отдельный клип. Благодаря этому она может поворачиваться независимо от лисы. Клип лисы по сравнению с предыдущей игрой не содержит анимации движения. Он является ни чем иным, как элементом фона игры, хотя и расположен поверх клипа соломинки.
Подготовка ролика
Подготовка ролика
Как и в первой игре этой главы, есть кадр стоящей лисы - "stand", и анимация ходьбы. У шарика есть нормальный кадр и анимация взрыва. Все шарики сначала серого цвета и потом раскрашиваются с помощью ActionScript. Пуля - это короткий клип-линия.
Подход
Подход
Для того чтобы соломинка была повернута в правильном направлении, прежде всего необходимо измерить горизонтальное и вертикальное расстояния между курсором и соломинкой, а затем с помощью этих значений вычислить необходимый угол.
Полученное значение можно использовать для поворота клипа coлoминки в нужном направлении. Оно также определяет место вылета снаряда и количество пикселов по горизонтали и вертикали, на которое снаряд перемещается в каждом кадре.
Добавить влияние гравитации немного проще. В начале движения объектата-пули его траектория слабо изменяется под действием гравитации. Однако с каждым кадром скорость падения увеличивается. Пуля получила сильный импульс при запуске, поэтому она будет продолжать двигаться вверх, но все медленнее и медленнее, по мере уменьшения ее кинетической энергии. Затем пуля все быстрее и быстрее начнет падать вниз.
Это явление называется ускорением свободного падения и в реальном мире составляет примерно 32 фута/с2 (9,8 м/с2). В мире игры ускорение может иметь любое значение.
Подход
Подход
Поведение лисы может остаться таким же, как в первой игре этой главы. Но поведение шариков должно быть полностью изменено. К тому же во время игры не должно быть создано ни одного нового шарика. Они все появляются в начале игры.
При попадании в шар запускается
Рисунок 10.3 При попадании в шар запускается воспроизведение анимации взрыва

Для окраски шара используются оттенки серого цвета. Цвет задается одновременно с созданием нового клипа шара. В результате один клип шара каждый раз принимает новый оттенок.
Клип снаряда содержит короткую линию. Хотя в качестве снаряда используется горошина, вертикальная линия создает видимость движения вверх.
Шарикизахватчики
Шарики-захватчики
Исходный файл: Ballooninvaders.fla
В самой классической видеоигре, "Космические захватчики", есть очень странное, но запоминающееся поведение вражеских единиц. Они движутся группой из стороны в сторону, медленно опускаясь вниз. Если они достигнут поверхности, игрок проигрывает.Давайте изменим первую игру данной главы так, чтобы воздушные шарики вели себя как космические захватчики.
Создание кода
Создание кода
Небольшой клип "actions" помешается за пределами рабочего поля и контролирует процесс игры путем обращения к функциям главной временной шкалы. Она запускает игру при загрузке и вызывает ряд функций в каждом кадре.
onClipEvent(load) {
_root.initGame();
onClipEvent(enterFrame) {
_root.newBalloon() ;
_root.moveBalloons() ;
_root.moveFox();
_root.moveBullets();
}
function initGame() {
// Инициализируем переменные, связанные с объектами-шарами.
nextBalloonTime = 0;
nextBalloon = 0;
balloons = [];
numBalloons = 10;
// Инициализируем переменные,
nextBulletTime = 0;
nextBullet = 0;
bullets = [];
// Количество очков равно 0.
score = 0;
}
После завершения проверок функция newBalloon создает новый шар с 50-процентной возможностью появления шара с левой или правой стороны. Скорость шара принимает произвольное значение от 3 до 5. Число является положительным, если шар будет пролетать слева направо и отрицательным в противном случае.
Цвет нового шара выбирается из пяти возможных оттенков. Для задания цвета используется функция setTransform.
Клипы шаров можно упорядочить, поместив их имена и значения скоростей в массив balloons.
Затем задаются переменные nextBalloon и nextBalloonTime, при помощи которых осуществляется обращение к переменной newBalloon.
function newBalloon () {
// Определяем, могут ли появиться новые шары,
if (nextBalloon < numBalloons) {
// Проверяем, пришло ли достаточно времени
// после появления последнего шара,
if (getTimerO > nextBalloonTime) {
// "Бросаем монетку",
if (Math.Random()
"balloon"+nextBalloon,
// Создаем новый шар.
attachMovie("balloon", nextBalloon);
// Выбираем, с какой стороны
// и с какой скоростью полетит шар.
if (Math.Random()
_root["balloon"+nextBalloon]._x = -30;
dx = int(Math.Random()*3)+3;
} else {
_root["balloon"+nextBalloon]._x = 580;
dx = -int(Math.Random()*3)-3;
// Выбираем высоту.
_root["balloon"+nextBalloon]._y = int(Math.Random()*100)+20;
// Выбираем цвет.
balloonColor = new Color("balloon"+nextBalloon)
r = int(Math.Random()*5)+1;
if (r == 1) {
balloonColor.setTransform({rb:255}) ;
} else if (r == 2) {
balloonColor.setTransform({gb:255}) ;
} else if (r == 3) {
balloonColor.setTransform({bb:255}) ;
} else if (r == 4) {
balloonColor.setTransform({rb:255,gb:255});
} else if (r == 5) {
balloonColor.setTransform({rb:255,bb:255});
}
// Добавляем новый шар.
balloons.push({clip:"balloon"+nextBalloon,d:dx});
// Изменяем значение переменных.
nextBalloon++;
nextBalloonTime = getTimerf) + 2000;
}}
}}
Чтобы быстро задать 50-процентную вероятность, лучше использовать фрагмент кода (Math. Random ()
Имейте в виду, что в цикле for функции moveBalloons перечисление осуществляется в обратном порядке: начинается с последнего элемента в массиве balloons и заканчивается 0. Благодаря этому удаление элемента не влияет на остальную часть массива. Предположим, из массива, состоящего из пяти элементов, был удален третий элемент. Тогда четвертый элемент становится третьим, а пятый - четвертым. Если бы вы считали в прямом направлении, вы бы пропустили третий элемент и сразу перешли к четвертому. При счете в обратном порядке такой проблемы не возникает.
function moveBalloons() {
// Перемещаем все шары,
for(i=balloons.length-1;i>=0;i--) {
// Определяем скорость шара
//и получаем ссылку на клип,
dx = balloons[i].d; balloon = _root[balloons[i].clip];
// Перемещаем шар.
balloon._x += dx;
// При вылете за экран шар удаляется,
if ((dx < 0) and (balloon._x < -20)) {
balloon.removeMovieClip() ;
balloons, splice (i,l);
} else if ((dx > 0) and (balloon._x > 570) balloon.removeMovieClip();
balloons.splice(i,1);
// Если шары закончились, игра завершается.
if ((nextBalloon >= numBalloons) and (balloons.length < 1)){
gotoAndStop("game over");
}}
function moveFox () {
// Подвинуть лису влево.
if (Key.isDown (Key.LEFT)) {
dx = -10;
fox._xscale = Math.abs(fox._xscale);
// Подвинуть лису вправо, перевернув ее клип по вертикали.
То есть изменив знак у свойства _scale, мы создаем зеркальное отражение клипа; лиса теперь идет в другую сторону.
}else if (Key.isDown(Key.RIGHT)) { dx = 10;
fox._xscale = -Math.abs(fox._xscale);
// Иначе лиса не двигается.
} else {
dx = 0;
// Перемещаем лису.
fox._x += dx;
if ((dx == 0) and (fox._currentFrame != 1)) {
// Переходим к кадру, в котором лиса стоит,
fox.gotoAndStop(1);
} else if ((dx != 0) and (fox._currentFrame == 1)) {
// Переходим к кадру, где лиса бежит.
fox.gotoAndPlay(2);
}
}
Функция shootBullet проверяет, прошло ли достаточно времени после предыдущего выстрела. Это не дает игроку возможности стрелять залпом по всем мишеням.
Подобно шарам снаряды представлены одновременно клипом и элементом массива, в данном случае массива bullets. Массив используется функцией moveBullets для осуществления выстрелов.
Обратите внимание, что движение клипа, содержащего снаряд, начинается в точке, расположенной в 2 пикселях вправо и 55 пикселях влево от центра клипа лисы. Эта точка соответствует кончику соломинки.
function shootBullet () {
// Проверяем, что с момента
// предыдущего выстрела прошло достаточно времени.
if (getTimerO > nextBulletTimei {
// Создаем новую пулю.
attachMoviet"bullet", "bullet'4nextBullet,nextBullet+9999) ;
// Устанавливаем ее координагы.
_root ["bullef+nextBullet] ._jc = fox._x+2;
_root [ "bullef+nextBullet] ._y = fo.x._y-55;
/ / Добавляем новую пулю к массиву.
bullets.push(nextBullet) ;
// Изменяем значение переменных, отвечающих
//за появление пуль.
nextBullet++;
nextBulletTime = getTimer()+1000;
}}
function moveBullets () {
/7 Проверяем, попали ли пули в шар.
for(i=bullets.length-1;i>=O;i--) {
// Выбираем элемент.
bullet = _root["bullet"+bullets[i]];
// Передвигаем пулю вверх,
bullet._y -= 10;
// Выясняем, достигла ли она конца экрана,
if (bullet._у < 0) {
bullet.removeMovieClip();
bullets.spliced,1) ;
// Определяем, не попал ли игрок по шару.
} else {
if (checkCollision(bullet)) {
bullet.removeMovieClip();
bullets.splice (i,1);
}}
}}
Почему для определения попадания используется функция distance, а не hitTest? Причина в том, что функция hitTest выдает значение true в случае, если снаряд попадет в любую часть шара, в том числе и в нитку, которая его держит
function checkCollision(bullet) {
// Просматриваем все шарики,
for(j =balloons.length-1;j >=0;j--) {
balloon = __root[balloons!j].clip];
// Проверяем, попала ли пуля.
if (distance(bullet,balloon) < 10) {
// Переходим к кадру, в котором шар взрывается.
balloon.gotoAndPlay(2);
// Убираем шар из массива,
balloons.splice(j,1);
// Увеличиваем счет,
score += 1;
// Возвращаем значение true,
return(true);
// Если игрок не попал, возвращаем значение false,
}}
return(false);
}
function distance(clipl, clip2) {
// Определяем расстояние между клипами,
dx = clipl._х - clip2._x;
dy = clipl._y - clip2._y;
return (Math.sqrt(dx*dx+dy*dy));
}
Создание кода
Создание кода
Некоторые функции данной игры аналогичны функциям игры "Стрельба по воздушным шарам", поэтому нет смысла рассматривать их повторно. Это функции initGame, newBalloon, moveBalloons, checkCollision и distance.
Одна из новых функций в анализируемой игре - aimStraw. Она заменит функцию moveFox и будет вызываться из клипа "actions", которому назначен следующий код:
onClipEvent(load) {
root.initGame();
onClipEvent(enterFrame) {
_root.newBalloon ();
_root.moveBalloons() ;
_root.aimStraw();
_root.moveBullets() ;
}
Углы измеряются в радианах или градусах. Полный круг в радианах будет равен 6,28 (2Pi), в градусах - 360. Радианы используются Flash в математических функциях наподобие Math.sin и Math.cos, а градусы - в параметрах клипов „rotation. Поэтому вы должны уметь преобразовывать значения из одних единиц измерения в другие.
Функция Math.atan2 является прекрасным инструментом для программирования игр. Арктангенс (во Flash - Math.atan) представляет собой функцию, вычисляющую угол наклона линии. Так как такой наклон определяется двумя точками, с помощью арктангенса можно преобразовать координаты этих точек в значение угла наклона. Однако при использовании арктангенса не учитывается, какая точка линии является анкером, а какая указателем, задающим угол. Поэтому легко получить углы, противоположные по значению тем, которые вам необходимы. Для того чтобы учесть различные варианты, необходимо написать несколько условных выражений. Функция Math.atan2 (y,x) вычисляет угол наклона линии между началом координат и точкой с координатами (х, у,). Тем самым решается проблема неоднозначности.
function aimStraw() {
// Определяем разницу координат начала
//и конца линии.
dx = _xmouse - straw._x;
dy = _ymouse - straw._y;
// Вычисляем угол наклона.
strawRadians = Math.atan2(dy,dx);
// Переводим полученное значение в градусы.
strawDegrees = 360*strawRadians/(2*Math.PI);
straw._rotation = strawDegrees;
}
К каждому объекту массива bullets будет добавлен параметр down, описывающий силу гравитации, действующую на пулю. Исходное значение этого параметра - 0.
Для того чтобы пуля вылетала из кончика соломинки, ее координаты должны иметь значение, равное значению координат соломинки плюс 20 пикселов (длина соломинки чуть больше 20 пикселов). Эти пикселы необходимо распределить (найти значения катетов при заданной гипотенузе и у угле) между координатами х и у при помощи функций Math.sin и Math.cos для того, чтобы получить горизонтальную и вертикальную стороны угла.
Функции Math.sin и Math.cos используются здесь для определения горизонтальной и вертикальной сторон угла. Для того чтобы наглядно представить это, возьмем круг, центр которого находится в точке 0,0; крайняя верхняя точка имеет координаты 0, -1(система координат, в которой ось Y направлена вниз); крайняя правая - 1,0. Задав в функции Math.sin любой угол, вы получите координату y этого угла на окружности. Функция Math.cos позволяет вычислить координату х. Таким образом, значение Math, sin (0) будет равно (-1), значение Math.cos (0) - 0, что соответствует координатам 0, -1.
Более важно понять то, что перемещение имеет две составляющие: скорость и угол. Значения расстояний для монитора компьютера не могут быть заданы по диагонали, они задаются только по вертикали и горизонтали. Функции Math, sin и Math.cos позволяют преобразовать значения скорости и угла в расстояние по горизонтали и вертикали.
function shootBullet () {
// Проверяем, можно ли выстреливать следующую пулю,
if (getTinerO > nextBulletTime) {
// Создаем пулю.
attachMovie("bullet","bullet"+nextBullet, L.nextBullet+9999);
bullet = _root["bullet"+nextBullet];
// Устанавливаем координаты.
bullet._x = straw._x + Math.cos(strawRadians)*20;
bullet._y = straw._y + Math.cos(strawRadians)*20;
// Добавляем в массив информацию о пуле:
// clip = название клипа,
// angle = начальный угол,
// down = эффект гравитации.
bullets.push({clip:bullet.angle:strawRadians,down:0}
// Увеличиваем счетчик пуль.
nextBullet++;
nextBulletTime = getTimer()+1000;
}}
Так как запушенный снаряд должен снова упасть на землю, прежде чем удалить его клип из массива, необходимо проверить, достиг ли он нижнего края экрана.
function moveBullets() {
// Перемещаем все снаряды.
for(i=bullets.length-1;i >=0;i —) {
// Определяем название клипа,
bullet = bullets[i].clip;
// Перемещаем клип.
bullet._x += Math.cos(bullets[i].angle)*10;
bullet._y += Math.sin(bullets[i].angle)*10;
// Добавляем искажение траектории
// из-за воздействия гравитации.
bullet._у += bullets[i].down;
// Увеличиваем значение параметра гравитации,
bullets[i].down += .2;
// Выясняем, достигла ли пуля земли,
if (bullet._у > 400) {
bullet.removeMovieClip();
bullets.splice(i,1);
// Определяем, есть ли попадение.
} else {
if (checkCollision(bullet)) {
bullet.removeMovieClip();
bullets.spliced(i, 1) ;
}}
}}
Создание кода
Создание кода
Клип "actions" такой же, как в первой игре этой главы, за исключением того, что новые шарики не создаются в каждом кадре.
onClipEvent(load) {
_root.initGame();
onClipEvent(enterFrame) {
_root.moveBalloons();
_root.moveFox();
_root.moveBullets();
}
function initGame() {
// Создаем шарики.
createBalloons О;
// Параметры снарядов.
nextBulletTime = 0;
nextBullet = 0;
bullets = [];
// Переменная счета.
score =0;
}
function createBalloons() {
balloons = new Array();
balloonNum = 0;
// Создаем новый ряд.
forfvar y=0;y
for(var x=0;x
// Создаем и размещаем новый шарик.
attachMovie("balloon", "balloon"+balloonNum, balloonNum) ;
balloonClip = this["balloon"+balloonNum];
balloonClip._x = x*30+20;
balloonClip._y = y*30+20;
// Добавляем в массив,
balloons, push (balloonClip) ;
// Устанавливаем цвет.
balloonColor = new Color(balloonClip);
if (y == 0) {
balloonColor.setTransform({rb: 255});
} else if (y == 1) {
balloonColor.setTransform({gb: 255});
} else if (y == 2) {
balloonColor.setTransform({bb: 255});
balloonNum++;}
}
// Направление (скорость) шариков.
balloonDirection = 3;
}
function moveBalloons() {
// Переменная-флаг изменения направления,
var newDirection = false;
// Просматриваем все шарики,
for(var i=0;i
// Передвигаем текущий шарик,
balloons[i]._x += balloonDirection;
// Смотрим, не достиг ли шарик границы экрана.
if ((balloonDirection > 0) and (balloons[i]._x > 530)) {
newDirection = true;
} else if ((balloonDirection < 0) and (balloons[i]._x < 20)) newDirection = true;
// При столкновении с границой экрана
// шарики опускаются и меняют направление.
if (newDirection) {
balloonDirection *= -1;
for(var i=0;i < balloons.length;i++) {
balloons[i]._y += 3;
//He достигли ли шарики земли?
if (balloons[i-l],_y > 300) {
gotoAndStop("game over");
}
}
function checkCollision(bullet) {
// Просматриваем все шарики,
for(j=balloons.length-1;j>=0;j—) {
balloon = balloons[j];
// Смотрим не попала ли пуля в шарик,
if (distance(bullet,balloon) < 10) {
// Удаляем шар из массива,
balloons.splice(j,1);
// Переходим в кадр взрыва шарика,
balloon.gotoAndPlay(2);
// Увеличиваем счет, score += 1;
// Если шаров больше нет - игра заканчивается,
if (balloons.length == 0) {
gotoAndStop("game over");
}
// Возвращаем значение true, так как попали в шарик,
return(true);
}}
// Возвращаем false, поскольку попали в шарик,
return(false);
}
Стрельба по воздушным шарам
Стрельба по воздушным шарам
Исходный файл: Balloonshoot.fla
Первая игра состоит из трех основных элементов: лисы, воздушных шаров и снарядов. В нашем примере лиса стреляет всего лишь горошинами из соломинки (Рисунок 10.1). Поэтому игра подойдет для любой аудитории.Стрельба с прицелом
Стрельба с прицелом
Исходный файл: Aimandshoot.fla
А что, если бы в предыдущей игре герой стоял, а не двигался из стороны в сторону? Тогда он бы мог направлять соломинку в любом направлении, а не только строго вверх. А снаряды подчинялись бы законам гравитации и, описав дугу, падали бы на землю.Ролик Aimandshoot.fla представляет собой как раз такую игру. На Рисунок 10.4 показан фрагмент игры; как вы можете видеть, лиса находится в центре экрана и стреляет под углом. Рассмотрим, как это можно сделать.
и подчинение пули закону гравитации.

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

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

Рис 10.5 Шарики-захватчики движутся группой
Между тем лиса внизу движется слева направо и стреляет в шарики. Она должна перестрелять их всех, прежде чем группа шариков достигнет поверхности земли.
Бита и блоки
Бита и блоки
Исходный файл: Paddlebricks.fla
Следующая игра намного сложнее двух предыдущих, хотя в ней используются те же основные элементы: мяч, бита и стены. Это классическая игра изначально называлась "Breakout". На Рисунок 11.4 показан фрагмент игры. В дополнение к мячу и бите вверху экрана расположены пять рядов блоков. Цель игры - выбить блоки с помощью мяча. Когда будут выбиты все блоки, игра переходит на следующий уровень, где мяч летит с большей скоростью.Бита и блоки три измерения
Бита и блоки: три измерения
Исходный файл: 3Dpaddlebricks.fla
Итак, в этой главе вы видели, как шар движется по плоскости. А что если шар должен будет двигаться в третьем измерении: в глубину? На Рисунок 11.5 показано, как это может выглядеть. Бита - это полупрозрачный квадрат на переднем плане игры. Четыре боковые стены ведут к задней стене, находящейся на некотором расстоянии "в глубине" экрана. Шар уменьшается по мере того, как становится все дальше от биты. Цель состоит в том, чтобы выбить все кирпичи (блоки) из задней стены.Цель этой игры такая же как и
Рисунок 11.5 Цель этой игры такая же, как и у предыдущей, но перспектива создает некоторую специфичность
Диаграмма показывает как изменяется
Рисунок 14.2. Диаграмма показывает, как изменяется положение мяча после столкновения со стеной

Столкновения с битой рассматриваются точно так же, как и столкновения со стеной. Единственное различие - вы должны изначально убедиться, что вертикальное положение биты допускает удар мяча об нее.
Если мяч проходит через горизонтальное положение биты, но ее там нет, нужно присвоить некой переменной значение, указывающее, что мяч был пропущен. Таким образом, у пользователя не будет другого шанса отбить мяч, пока тот летит до границы экрана.
Другие возможности
Другие возможности
Игру можно усовершенствовавать, если позволить игроку пропустить в течение игры определенное количество мячей. Таким образом, игра не будет заканчиваться после пропуска первого мяча, а продолжится со вторым мячом и т.д.
Осуществить это можно, присвоив, например, в начале игры переменной ballNum значение 3 или какое-либо другое. В результате, если велична ballNvun будет превышать 0, вместо кадра "game over" ролик будет переходить к кадру "ball lost". Игрок может нажать любую клавишу и начать игру заново, но при этом значение ballNum
Другие возможности
Другие возможности
Изменить количество мячей просто: достаточно изменить только одно значение в кадре "start game". Изменяя другие параметры, можно продлить или усложнить игру. Есть и другие варианты усовершенствования игры - например, увеличить скорость биты компьютера, поменяв одно значение в функции moveComputerPaddle.
Также можно сделать компьютер "умнее". Например, написать код, который будет предугадывать место, куда прилетит мяч, и передвигать туда биту вместо того, чтобы просто перемешать ее вслед за мячом. При пересечении границ игрового поля мяч будет ударяться о верхнюю или нижнюю стенку только один раз, так что определить предполагаемое место можно с помощью простых математических расчетов, если вы хорошо владеете математикой.
Другие возможности
Другие возможности
Игра станет интереснее, если в ней будет подсчет очков. Здесь это не сделано для того, чтобы не усложнять код. Просто добавьте текстовое поле "score" и свяжите его с переменной score. Затем прибавляйте единицу каждый раз, когда игрок выбивает блок.
Возможно, вам также захочется добавить текстовые поля, чтобы сообщать пользователю, на каком он уровне и сколько осталось мячей. Можно добавить и звуковые эффекты.
Другие возможности
Другие возможности
Очень простой способ внести дополнение в эту игру - поместить какой-либо рисунок за блоками. Это можно сделать вообще без использования ActionScript. Можно также сделать, чтобы в конце каждого уровня пользователь видел другую картинку.
Элементами игры "Стена и мяч"
Рисунок 11.1 Элементами игры "Стена и мяч" являются мяч, бита и три стены
К сведению
К сведению
Убедитесь, что экземпляру клипа с мячом присвоено имя "ball", а экземпляру клипа с битой - "paddle". Если стены расположены не так, как в исходном ролике, проверьте, правильно ли указаны константы в функции initGame.
В основной кадр игры необходимо включить оператор stop, чтобы вставить паузу в основную временную шкалу (это поможет избежать досрочного перехода к кадру окончания игры).
К сведению
К сведению
В дополнение к уже описанным элементам необходимо создать текстовые поля playerScore и computerScore и поместить их на рабочее поле. Они должны быть расположены во всех кадрах, кроме "start game", таким образом, чтобы были видны между подачами мяча и в конце игры.
К сведению
К сведению
Для работы кода необходимо точно указать множество элементов. Запустите ролик Paddlebricks.fla, чтобы посмотреть готовый вариант программы в действии. Для создания своей собственной версии необходимо запомнить имена всех клипов и в каждый кадр вставить команду stop. Также нужно вставить небольшие фрагменты кода в кнопки и первый кадр.
Ряды блоков были раскрашены с помощью эффекта Tint (Окраска), благодаря чему игра стала визуально более интересной. Вы можете выбрать другое графическое решение, ничего не меняя в функциональной части игры.
К сведению
К сведению
Игра, в общем то, лишь приблизительно воспроизводит трехмерный мир. Например, когда мяч отлетает в угол, компонент скорости z меняется таким образом, что суммарный вектор скорости остается неизменным Вы можете попробовать спрятать курсор перед началом игры с помощью Mouse.hide (), только не забудьте вернуть его на место по окончании игры с помощью Mouse. show ().
Мяч и бита
Мяч и бита
Исходный файл: Paddleball.fla
Хотя предыдущая игра веселая, у нее есть один недостаток: нет никакой возможности выиграть. Вы просто играете до тех пор, пока не надоест или пока не проиграете.Игра станет более интересной, если позволить игроку управлять одной битой в то время, как компьютер будет управлять другой. Игрок попытается не пропустить мяч, надеясь на то, что его пропустит компьютер.

Подготовка ролика
Подготовка ролика
Единственными фафическими объектами, необходимыми для этой игры являются мяч, бита и стены. Изображения стен не используются в коде, так как реальные фаницы ифового поля определяются с помощью значений определеннных констант.
Подготовка ролика
Подготовка ролика
В общих чертах ролик аналогичен предыдущему. Вместо трех кадров вам понадобятся четыре: "start game", "start level", "play" и "game over". Перед каждой подачей мяча будет виден кадр "start level". Кадр же “game over" станет отображаться только тогда, когда будет пропущен последний мяч.
Как и в предыдущей игре, вам нужен один клип под названием "paddle» и еше один с именем "computerPaddle". Поведение второй биты будет запрограммировано с помощью языка ActionScript. Так как бита компьютера будет располагаться справа, необходимо убрать правую стенку. При этом верхняя и нижняя стены останутся.
Подготовка ролика
Подготовка ролика
Для этого ролика нужно пять кадров, то есть больше, чем в ранее рассмотренных играх. Первый кадр - "start game". Он появляется только в начале игры. Щелчок по кнопке Play переводит игрока непосредственно в кадр "play", и игра начинается.
Второй кадр - это "start level". Он отображается, когда игрок переходит на второй и последующие уровни. Здесь щелчок по кнопке Play также переносит игрока в кадр "play", то есть к началу нового уровня.
Третий кадр - "start ball". Он отображается, когда игрок пропускает мяч и хочет подать себе следующий. Внимательно рассмотрите исходный файл. Как видите, блоки присутствуют в третьем и четвертом кадрах, то есть в кадре "play". Таким образом, изображения блоков сохраняются, пока ролик переходит от кадра "play" к кадру "start ball". Иначе блоки будут расположены на своих исходных позициях.
Последний кадр - "game over". Щелчок по кнопке Play перенесет игрока обратно к кадру "start game", где значения некоторых важных параметров будут восстановлены.
Кроме организации расположения кадров необходимо создать блоки для третьего и четвертого кадров. В исходном ролике блоки имеют ширину 48 пикселов и высоту 8 пикселов. В примере расстояние между ними составляет 50x10 пикселов, таким образом, получается 5 рядов блоков по 11 блоков в каждом, что в общей сложности составляет 55 блоков.
Для того чтобы не именовать 55 блоков на рабочем поле, подумайте, а не начать ли игру вовсе без блоков, а затем воспользоваться оператором attachMovie, чтобы добавить каждый блок с помощью кода. Хотя данная техника здесь не применяется, можно посмотреть, как она реализована в следующей игре этой главы.
К сожалению, каждому блоку должно быть присвоено имя, чтобы код мог его распознать. В исходном файле им назначены имена от al до а55. Клип с мячом называется "ball", а с битой - "paddle".
Подготовка ролика
Подготовка ролика
Ролик включает в себя четыре кадра. Все действия происходят во втором кадре. Фоном для всех кадров служит параллелепипед, показанный на Рисунок 11.5. Его внешняя граница размером 400x400 полностью заполняет рабочее поле. Внутренняя граница, представляющая заднюю грань, имеет размер 120x120 и располагается точно в центре.

Остальные клипы также находятся на экране. Первый - это бита, квадрат размером 70x70. Этому клипу присвоено имя "paddle" и его параметр _alpha=50%, что делает его полупрозрачным. Мяч - это клип "ball", содержащий круг диаметром 30 пикселов. Также в стороне расположен клип "action".
В библиотеке есть также клип "brick". Клип экспортируется вместе с роликом. Он используется для создания кирпичей, которые покрывают заднюю стену.
Если вы внимательно посмотрите на рисунок 11.5, то кроме толстых линий наружной и внутренней стен можете увидеть контур из тонких линий где-то в середине. Этот набор линий движется вместе с мячом вглубь экрана. Он помогает игроку определить, где находится мяч. Посмотрите ролик-пример, чтобы увидеть, как это работает. Вам нужен, клип размером 400x400, чтобы сделать эти линии. В примере этот клип называется "ring".
Подход
Подход
Искусственный интеллект для этой игры можно создать разными способами. Один из них - сделать так, чтобы бита всегда следовала за мячом. Однако в этом случае у компьютера просто не будет возможности пропустить мяч.
Лучше, если бита компьютера будет медленно двигаться в направлении мяча. Если мяч будет лететь слишком быстро, компьютер может не успеть переместить биту в правильное положение. Кроме того, бита будет двигаться только тогда, когда мяч летит в искусственного противника.
Словосочетание "искусственный интеллект" звучит таинственно. Однако для игр не так важно, чтобы противник был умным. Компьютер должен только способствовать захватывающей игре. Конечно, в большинстве игр гораздо проще создать безупречного противника. Однако в таком случае игра для компьютера становится беспроигрышной, что не интересно для игрока. Трудность состоит в том, чтобы создать противника, обладающего некими навыками (это сделает игру непростой), но чтобы имеющихся навыков не хватало для беспроигрышной игры.
Для того чтобы счет игры был сохранен, нужны несколько переменных. Однако создать паузу в игре между подачами мяча довольно сложно, поэтому в игре будет два кадра: в первом программа ждет, когда игрок щелкнет по кнопке "serve", а во втором разворачивается само действие игры. Этот второй кадр начинается с установки произвольного начального положения мяча.Подход
Подход
Код для определения, в каком месте биты или стены ударился мяч, похож на код предыдущих двух игр. Единственное отличие заключается в том, что теперь мяч может отскакивать не только от верхней биты, а и от любой ее точки. Таким образом, становится немного проще отбить мяч.
При столкновении мяча с блоком направление его движения по вертикали изменяется на противоположное. Блок же удаляется с экрана.
В предыдущих играх было достаточно определить, когда мяч ударяется о блок, для чего использовался метод hitTest. Теперь задача усложняется: надо рассмотреть все четыре стороны мяча по отношению ко всем четырем сторонам блока. Если мяч и блок полностью перекрываются, то считается, что произошло столкновение. С помощью метода hitTest можно было бы определить момент, когда мяч находится внутри прямоугольного блока. Но этого не достаточно для данной игры.
При столкновении мяча с битой рассчитывается расстояние между центром мяча и центром биты. Длина биты - 50 пикселов, так что это расстояние может быть чуть более 25 пикселов, либо со знаком "+", либо со знаком "-". Разделите данное число на 4 и получите значение между -7 и 7.
Новое значение будет присвоено переменной dx, которая определяет скорость движения мяча по горизонтали.
Это значит, что игрок может направлять мяч. Если, например, он отобьет мяч левым краем биты, мяч будет направлен резко влево. Если же отбить серединой биты, то мяч полетит прямо вверх.
Подход
Подход
Чтобы следить за положением мяча, необходима новая переменная. Можно использовать х для горизонтальной и у для вертикальной характеристики положения шара. Третья переменная, z, следит за глубиной -как глубоко внутри экрана находится шар.
Эти три переменные определяют положение мяча внутри воображаемого параллелепипеда, в котором происходит игра. Этот параллелепипед имеет горизонтальные и вертикальные размеры по 400 единиц и 140 единиц в глубину. Чтобы перевести это в координаты экрана, нужна некоторая ловкость. Если вы еще раз посмотрите на Рисунок 11.5, то заметите, что границы шахты видимы. Наружный квадрат (грань), ближний к игроку, находится на том же уровне, что и бита. Он имеет размер 400x400. Внутренняя грань, представляющая заднюю стену, имеет размер 120x120.
На рисунке 11.6 еще раз изображены обе грани, но на этот раз с обозначенными х, у и z координатами. Верхний левый угол обеих граней имеет значения х и у равные 0. Однако наружный угол имеет значение z равное 0, а внутренний - значение z, равное 140. Остальные углы обозначаются аналогично.
Если мяч находится на позиции (х, у) = (0,0) и движется от 0 к 140 вдоль оси Oz, то он движется вдоль ребра параллелепипеда (Рисунок 11.6). Если мяч в центре экрана, в положении (200,200), и движется от 0 до 140 вдоль Oz, ему вообще не нужно смешаться вправо или влево. Если мяч в какой-нибудь промежуточной позиции, например (50,65), и движется от 0 до 140 вдоль Oz, то он должен двигаться вдоль своей линии перспективы так, чтобы сохранить свое положение относительно передней и задней граней.
Иллюзия трехмерности достигается также за счет уменьшения значения масштаба мяча по мере его удаления.
Создание кода
Создание кода
Для этой игры необходимы лишь три функции (посмотрите исходный файл, Wallball.fla). Все эти три функции будут вызываться в клипе "actions”:
onClipEevent(load) {
_root.initGame();
}
onClipEvent(enterFrame) {
_root.moveBall();
_root.movePaddle () ;
}
function initGame() {
// Устанавливаем начальное положение мяча,
х = Ьа11._х;
у = ball._y;
// Указываем начальную скорость,
dx = 5;
dy = 5;
// Устанавливаем значения постоянных.
rightwali = 550;
leftWall = 0;
topWall = 0;
bottomWall = 4 4 0;
ballRadius = ball._width/2 passedPaddle = false;
// Прячем курсор.
Mouse.hide();
}
К радиусу мяча прибавляется значение его положения, чтобы получить точную позицию правого края мяча. Если мяч оказался за стеной, функция movePaddle подсчитывает, как далеко он перелетел, и присваивает это значение переменной overshoot. Затем мяч перемешается назад на расстояние, в два раза превышающее значение overshoot. Направление мяча меняется при умножении dx на -1, таким образом, знак dx меняется на противоположный. Если значение dx до столкновения мяча со стеной было равно 5, то после этого события становится равным -5.
Затем код проверяет, пролетел ли мяч сквозь нижнюю стену или нет (3). Этот фрагмент похож на предыдущий, только вместо х и dx используются величины у и dy.
Фрагмент кода, где проверяется, пролетел ли мяч через верхнюю стену, несколько отличается от уже рассмотренных (4). Для определения положения верхней границы мяча из положения его центра вычитается радиус. Затем величина overshoot рассчитывается как разница между положениями стены и верхней границы мяча.
Для того чтобы определить, ударился ли мяч о биту или нет, сначала код рассчитывает положение правой границы биты (5). Потом, если мяч находится достаточно близко к бите, рассчитываются верхняя и нижняя границы, а затем определяется, пересекаются ли мяч и бита (6).
Если мяч сталкивается с битой, то он ведет себя так же, как и при столкновении со стеной. Однако при этом скорость мяча увеличивается на 5% (7). Если мяч перелетает через стену, совершается только одно действие - переменной passedPaddle присваивается значение true.
Если значение переменной passedPaddle равно true, и мяч находится там, где должна быть левая стена, игра заканчивается (8). Курсор возвращается в исходное положение, и ролик переходит к кадру "game over".
В конце функции moveBall положение мяча устанавливается в соответствии со значениями х и у.
Оператор *= работает точно так же, как и +=, только он умножает исходное значение переменной на указанное число. То есть если значение а равно 5, строка а *= 3 изменит это значение на 15. Если же записать а *= -1, значение переменной а станет равным - 5. Воспользовавшись записью *= - 1 можно быстро изменить знак переменной.
function moveBall() {
(1)// Изменяем значение переменных х и у.
х += dx;
У + = dy;
(2)// Проверяем, достиг ли мяч правой стены,
if (x+ballRadius > rightWall) {
overshoot = (x+ballRadius) - rightWall x -= overshoot*2;
dx *= -1;
(3)// Проверяем, достиг ли мяч нижней стены,
if (y+ballRadius > bottomWall) {
overshoot = (y+ballRadius) - bottomWall;
у -= overshoot*2;
dy *= -1;
(4)// Проверяем, достиг ли мяч верхней стены,
if (y-ballRadius < topWall) {
overshoot = topWall - (y-ballRadius);
у += overshoot*2;
dy *= -1;
(5)// Находится ли мяч там, где должен удариться о биту?
paddleRight = paddle._x+(paddle._width/2);
if ((x-ballRaduis < paddleRight) and passedPaddle) {
(6)/ / Находится ли там бита?
paddleTop = paddle._y-(paddle._height/2);
paddleBottom = paddle._y+(paddle._height/2);
if ((y > paddleTop) and (y < paddleBottom)) {
// Удар о биту.
overshoot = paddleRight х += overshoot*2;
dx *= -1;
(7) // Увеличиваем скорость,
dx *= 1.05; dy *= 1.05;
} else {
// Мяч пропущен, больше ничего проверять не надо.
passedPaddle = true;}}
(8)// Проверяем, находится ли мяч у левой стены,
if ((x-ballRadius < leftWall) and passedPaddle) {
Mouse.show();
GotoAndPLay("game over");}
// Устанавливаем новое положение мяча.
ball._x = х,-ball._y = у; }
}
function movePaddle() {
// положение биты меняется в соответствии с курсором
paddle._у = _ymouse;
}
Создание кода
Создание кода
В сценарий предыдущего ролика необходимо внести некоторые изменения. Изменить существующие функции и добавить одну новую. Приведем сценарий клипа "actions", который вызывает новую функцию moveComputerPaddle:
onClipEvent(load) {
_root.startLevel();
}
onClipEvent(enterFrame) {
_root.moveBall ();
_root.movePaddle() ;
_root.moveComputerPaddle();
}
function startLevel() {
// Определяем начальное положение мяча,
х = ball._x;
у = ball._y;
// Указываем начальную скорость и одно из четырех
// произвольных направлений по диагонали,
dx = 5;
dy = 5;
if (Math.random() < .5) dx *= -1;
if (Math.random() < .5) dy *= -1;
// Прячем курсор. Mouse.hide();
// Устанавливаем значения констант.
rightWall = 550;
leftWall = 0;
topWall = 0;
bottomWall = 400;
ballRadius = ball._width/2;
passedPaddle = false;
}
Когда мяч пролетает с правой (11) или с левой (12) стороны, обычно игра возвращается к кадру "start level". Однако если не осталось больше мячей, программа переходит к кадру завершения игры, "game over". В зависимости от того, кто пропустил мяч, очко записывается либо игроку, либо компьютеру (переменной playerScore или computerScore).
function moveBall() {
// Изменяем координаты х и у.
х += dx;
y += dy;
// Проверяем, попал ли мяч в нижнюю стену,
if (y+ballRadius > bottomWall) {
overshoot = (y+ballRadius) - bottomWall;
у -= overshoot*2;
dy *= -1;
}
// Проверяем, попал ли мяч в верхнюю стену, if (y-ballRadius < topWall) {
overshoot = topWall - (y-ballRadius);
у += overshoot*2;
dy *= -1;}
(9) // Находится ли мяч там, где по нему должна ударить бита?
paddleRight = paddle._x+(paddle._width/2);
if ((x-ballRadius < paddleRight) and ipassedPaddle) {
// Находится ли там бита?
paddleTop = paddle._y-(paddle._height/2);
paddleBottom = paddle._y+(paddle._height/2);
if ((y > paddleTop) and (y < paddleBottom)) {
overshoot = paddleRight - (x-ballRadius)
// Удар битой,
x += overshoot*2;
dx += -1;
// Увеличиваем скорость мяча,
dx *= 1.05;
dy *= 1.05;
} else {
// Мяч пропущен, больше ничего не проверяем.
passedPaddle = true;}
}
(10) // Находится ли мяч там,
// где должен столкнуться с битой компьютера?
paddleLeft = computerPaddle._x-(computerPaddle._width/2);
if ((x+ballRadius > paddleLeft) and !passedPaddle) {
// Находится ли тем бита?
paddleTop = computerPaddle._y-(computerPaddle._height/2);
paddleBottom = computerPaddle_>y+
(computeerPaddle._height/2);
if ((y > paddleTop) and (y < paddleBottom)) {
// Удар битой.
oveershoot = (x+ballRadius) - paddleLeft;
x -= overshoot *2; dx *= -1;
// Увеличиваем скорость мяча,
dx *= 1.05;
dy *= 1.05;
} else {
// Мяч пропущен, ничего больше не проверяем.
passedPaddle = true;
}}
(11) // Проверяем, попал ли мяч в левую стену.
if ((x-ballRadius < leftWall) and passedPaddle) {
Mouse.show();
computerScore++;
if (numBalls == 0) {
gotoAndPlay("game over");
} else {
numBalls--;
gotoAndPlayf"start level");}}
(12) // Выполняем аналогичную проверку для правой стены,
if ((x+ballRadius > rightWall) and passedPaddle) {
Mouse.show();
playerScore++;
if (numBalls == 0) {
gotbAndPlay("game over");
} else {
numBalls-;
gotoAndPlay("start level");
// Устанавливаем новое положение мяча.
ball._x = х;
ball._y = у;
}
Скорость передвижения биты устанавливается в начале функции. Чем выше это значение, тем быстрее бита будет реагировать на перемещения мяча.
function moveComputerPaddle() {
// Устанавливаем скорость биты, управляемой компьютером.
moveAmount = 8;
// Выясняем, движется ли мяч в этом направлении,
if (dx > 0) {
// Перемещаем биту вверх.
if (у < computerPaddle._y-moveAmount) {
computerPaddle._y -= moveAmount;
,// Перемещаем биту вниз.
} esle if (у > computerPaddle._y+moveAmount) {
computerPaddle._y += moveAmount;
}}}
numBalls = 7;
computerScore = 0;
playerScore = 0;
stop();
Создание кода
Создание кода
Прежде чем будет запушен кадр игры, в кадре "start game" необходимо определить две важные переменные: начальную скорость движения мяча по вертикали и количество мячей, которые могут быть поданы.
dy = 3;
numBalls = 3;
stop() ;
onClipEvent(load) {
_root.startBall();
onClipEvent(enterFrame) {
_root.moveBall();
_root.movePaddle();
_root.checkCollisions();
}
Вдобавок к параметрам мяча воспользуйтесь возможностью и установите некоторые значения, которые не будут изменяться во время игры.
function startBall() {
// Определяем начальное положение мяча,
х = ball._x;
у = ball._y;
// Устанавливаем начальную скорость по горизонтали,
dx = 3;
// Прячем курсор.
Mouse.hide();
// Задаем значения констант.
rightWall = 550;
leftWall = 0;
topWall = 0;
bottomWall = 400;
ballRadius = ball,_width/2;
paddleTop = paddle._y-paddle._height/2;
paddleBottom = paddle._y+paddle.__height/2;
}
// Бита следует за курсором,
function movePaddle() {
paddle._x = _xmouse;
}
Для того чтобы узнать, ударился ли мяч о биту, код проверяет, полностью ли они перекрываются (13). Затем, если все-таки столкновение произошло, скорость мяча по горизонтали определяется тем, где именно мяч ударился о биту (14). К тому же код для определения, пропущен ли мяч, проще, так как он просто проверяет, пролетел ли мяч сквозь нижнюю стену или нет (15).
function moveBall() {
// Изменяем горизонтальное и вертикальное положение мяча.
х += dx;
У += dy;
// Проверяем, находится ли мяч у правой стены,
if (x+ballRadius > rightWall) { overshoot = (x+ballRadius) - rightWall;
x -= overshoot*2;
dx *= -1;
// Проверяем, находится ли мяч у левой стены.
if (x-ballRadius < leftWall) {
overshott = leftWall - (x-ballRadius);
x += overshoot*2;
dx *= -1;
// Проверяем, находится ли мяч у верхней стены,
if (y-ballRadius < topWall) {
overshoot = topWall - (y-ballRadius);
у += overshoot*2;
dy *= -1;
(13)// Находится ли мяч там, где должен удариться о биту?
if ((y+ballRadius > paddleTop) and (y-ballRadius < paddleBottom)) {
// Находится ли там бита?
paddleLeft = paddle._x-(paddle._width/2);
paddleRight = paddle._x+(paddle._width/2);
if ((x+ballRadius > paddleLeft) and (x-ballRadius < paddleRight)) {
// Удар о биту.
overshoot = paddleTop- (y+ballRadius);
у += overshoot*2;
dy *= -1;
(14) // Указываем горизонтальную скорость мяча
//в зависимости от места соприкосновения мяча и биты.
dx = (ball._x - paddle._x)/4;
} else {
// Мяч пролетел мимо биты
passedPaddle = true;
(15) // Проверяем, пролетел ли мяч мимо биты.
if (у > bottomWall) {
Mouse.show() ;
if (numBalls == 0) {
// Больше мячей нет, конец игры.
gotoAndPlay("game over");
} else {
// Еще остался мяч.
numBalls--;
gotoAndPlay("start ball");
}
} // Определяем расположение мяча,
ball._x = х;
ball._y = у;
}
Обратите внимание на переменную leveldone. Изначально ее значение равно true, но оно изменяется на false, как только встречается блок, который не был сбит. Если значение переменной leveldone все еще остается истинным после того, как были использованы все мячи, игроку удалось удалить все блоки. Игра переходит к кадру "start level", но прежде увеличивается скорость мяча по вертикали, то есть переменная dy.
Необходимо проверить, превышает ли скорость мяча по вертикали значение 7, если да, то нужно снова присвоить ей значение 7. Это вызвано тем, что блоки имеют 8 пикселов в высоту. Если скорость мяча будет равна 8 пикселям или более, тогда мяч будет перелетать через блоки, не выбивая их. К. счастью, скорость, равная 7, и так слишком велика - даже хороший игрок долго не продержится.
function checkCollisions() {
// Определяем границы мяча. ballTop = ball._y - ball._height/2;
ballBottom = ball._y + ball._height/2;
ballLeft = ball._x - ball._width/2;
ballRight = ball._x + ball._width/2;
// Допускаем, что уровень пройден,
leveldone = true;
// Выясняем, ударил ли мяч по блоку,
for (i = l; i < = 55 ; i + +)
{ brick = _root["a" + i] ;
// Проверяем, есть пи еще блоки вокруг,
if (brick._х о -1000) {
if (brickHit(brick)) {
// Если по блоку ударили,
// его нужно удалить с экрана.
brick._х = -1000;
// Изменяем направление движения мяча,
dy *= -1;
} else {
// Блоки еще остались, так что уровень
//не закончен,
leveldone = false;
}}
} // Все ли блоки уже выбиты?
if (leveldone) {
// Начать новый уровень.
Mouse.show();
gotoAndPlay("start level");
// Увеличиваем скорость движения мяча по вертикали.
dy += 1;
if (dy > 7) dy=7;
}
}
Обратите внимание, что в функции hitBrick находятся четыре вложенных оператора if. Возможно, вам будет интересно, почему не написать четыре условия в линию, соединив их оператором AND. Дело в скорости. С вложенными операторами if, если одно из условий оказалось ложным, программа не будет проверять остальные. Таким образом, значительно сократится объем работы, которую выполняет программа, и скорость игры увеличится. С операторами AND программе Flash придется проверять все четыре условия, даже если первое из них ложное.
Функция hitBrick проверяет все четыре стороны мяча по отношению ко всем четырем сторонам блока, чтобы узнать, перекрывает ли мяч один из них. Функция возвращает значение либо true, либо false.
function brickHit(brick) {
// Проверяем, попал ли мяч по блоку.
if (ballTop
if (ballBottom >= brick._y - brick._height/2) {
if (ballRight >= brick._x - brick._width/2) {
if (ballLeft
// Все условия верны, то есть мяч
// столкнулся с блоком,
return(true);
}}}}
// Мяч не столкнулся с блоком,
return(false);
}
Создание кода
Создание кода
Код состоит в основном из функций, расположенных во втором кадре. Первая начинает игру. Вместо отдельных переменных для хранения х, у и z значений мяча, мы используем один объект, ballpos, который имеет о свойства. Таким образом, ballpos .x соответствует x-положению мяча. То же самое мы делаем для ballvel, где содержатся х, у и z скорости мяча.
В начале игры значения свойств объекта bollpos устанавливаются таким образом, чтобы мяч начинал свое движение от задней стенки параллелепипеда. Значения объекта ballvel задают начальное движение мяча строго вдоль оси Oz и скорость на единицу большую номера уровня игры (то есть 2).
Следующая часть функции initGame создает 16 блоков из одного библиотечного образца и покрывает ими всю заднюю стенку. В заключении функции мы устанавливаем уровень биты и шара так, чтобы они были расположены поверх созданных кирпичей.
function initGame() {
// Устанавливаем мяч.
ballpos = {х:200, у:200, z:140};
// Определяем его скорость.
ballvel = {х:0, у:0, z:-(1+gameLevel)};
// Создаем блоки,
bricks = new Array();
for(var x=0;x
for(var y=0;y
brick = attachMovie("brick","brick"+x+y,x+y*4);
brick._x = 155+30*x;
brick._y = 155+30*y;
bricks.push(brick);
// Перемещаем биту и шар на передний план.
paddle.swapDepths(101);
ball.swapDepths(100);
}
onClipEvent(enterFrame) {
_root.movePaddle();
_root.moveBall(); }
Первая из этих функций, movePaddle, очень простая. Она устанавливает биту в позицию курсора.
function movPaddle() {
//Положение биты соответствует положению курсора.
Paddle._x=_root._xmouse;
Paddle._y=_root._ymouse;
}
Затем вычисляется положение мяча на экране (17). Координата х определяется как значение ballpos. х, подкорректированное в соответствии со значением ballpos.z. Чем глубже находится шар, тем большую величину составляет поправка. Второй множитель поправки определяется тем, насколько далеко находится шар от стенок колодца. Если, например, шар находится ровно посередине между стенкой и центральной осью, то есть ballpos.х = 100 или (-100), то поправка будет равняться значению ballpos.z (ballpos.z соответственно). Если вы не вполне поняли логику этих рассуждений, попробуйте поменять различные параметры объекта bollpos и посмотрите на результат.
Следующий фрагмент кода устанавливает значение масштаба шара в соответствие со значением ballpos.z (18). Поскольку максимальное значение ballpos.z составляет 140, то минимальный масштаб составляет (200-140)/2, то есть 35%.
Далее мы устанавливаем масштаб клипа "ring" (19). Этот клип выполняет роль указателя, помогающего понять, на какой глубине находится шар в данный момент.
Если шар сталкивается с одной из стен параллелепипеда (20), происходит отражение от стенки. Проверка выполняется для всех четырех стен.
Столкновение с задней стенкой (21) обрабатывается несколько сложнее. Значение z меняется на противоположное. Кроме того, клипы блоков проверяют, куда именно врезался шар. Блок, с которым произошло столкновение, удаляется, и счет увеличивается.
Передней стенки у нас нет, но на ее месте располагается бита. Если параметр z принимает значение 0, клип биты проверяет, попал ли в него? шар (22). Бита имеет размер 70x70, так что шар должен находиться не далее чем в 35 пикселях по каждой из координат от центра биты. При столкновении определяются новые значения скорости шара в соответствии с расстоянием от центра биты до места столкновения (23). При столкновении строго по центру шар отражается отвесно, тогда как отражение, например, от левой стороны отклоняет мяч влево и т.д.
При столкновении с битой ее параметр _alpha на мгновение принимает значение 90 (24). В следующем кадре значение восстанавливается (26).
Если шар пролетает мимо биты, игра заканчивается (25). Если же все блоки оказываются выбиты, игрок переходит на следующий уровень.
function moveBall() {
(16)// Определяем пространственные координаты шара.
ballpos.х += ballvel.x;
ballpos.у += ballvel.у;
ballpos.z += ballvel.z;
(17) // Определяем плоские координаты.
ball._x = ballpos.x + ballpos.z*(200-ballpos.x)/200;
ball._y = ballpos.у + ballpos.z*(200-ballpos.у)/200;
(18) // Корректируем размер шара.
ball._xscale = (200-ballpos.z)/2;
ball._yscale = (200-ballpos.z)/2;
(19) // Определяем размер рамки.
ring._xscale = (200-ballpos.z)/2;
ring._yscale = (200-ballpos.z)/2;
(20) // Проверяем столкновения со стенками,
if (ballpos.x > 400) ballvel.x *= -1;
if (ballpos.x < 0) ballvel.x *= -1;
if (ballpos.у > 400) ballvel.у *= -1;
if (ballpos.у < 0) ballvel.у *= -1;
(21) // Столкновение с задней стеной,
if (ballpos.z > 140) {
// Меняем направление вдоль
Oz. ballvel.z *= -1;
// Удаляем выбитые шары.
for(var i=bricks.length-1;i>=0;i--) {
if (bricks[i].hitTest(ball._x,ball._y)) {
bricks[i].removeMovieClipt);
bricks.splice(i,1);
score++;}}}
(22) // Столкновение с битой.
if (ballnos.z < 0) {
// Расстояние до центра биты,
рх = ballpos.x-paddle._x;
ру = ballpos.y-paddle._y;
// Столкновение происходит, если расположение от шара
//до центра биты не более 35 пикселов.
if ((Math.abs(px) < 35) and (Math.abs(ру) < 35)) {
(23) // Корректируем скорости по х и по у.
ballvel.x = рх/7; ballvel.y = ру/7;
(24) //Отмечаем столкновение изменением прозрачности биты.
paddle._alpha = 90;
} else {
(25) // Мяч пропущен.
removeBallAndPaddle();
gotoAndStop("game over");
// Меняем направление мяча вдоль Oz.
ballvel.z *= -1;
} else {
(26) // Возвращаем бите прежнюю прозрачность,
paddle._alpha = 50;
(27)// Смотрим, все ли блоки выбиты,
if (bricks.length < 1) {
gameLevel++;
removeBallAndPaddle();
gotoAndStop("level over");
}}
}
function rernoveBallAndPaddle (){
paddle.removeMovieClip();
ball.removeMovieClip(); }
function removeBricks() {
for(var i=0;i
bricks[i].removeMovieClip();
}}
gameLevel=1;
stop();
on (press) {
GotoAndStop("Play");
}
on (press) {
removeBricks();
gotoAndStop("Play");
}
on (press) {
removeBricks();
gotoAndStop("Start");
Стена и мяч
Стена и мяч
Исходный файл: Wallball.fla
Первая игра называется "Стена и мяч". В ней имеются бита, управляемая пользователем, и три стены, от которых может отскакивать мяч. Четвертой стены нет (она открыта). Задача игрока состоит в том, чтобы не позволить мячу пролететь мимо биты (Рисунок 11.1).В игре "Бита и блоки" представлены
Рисунок 11.4 В игре "Бита и блоки" представлены ряды блоков, которые игрок должен выбить с помощью мяча
Самое сложное при создании этой
Подход
Самое сложное при создании этой игры - сделать так, чтобы мяч правильно отскакивал от стен. Многие программисты не учитывают ни диаметр мяча, ни его скорость. В результате может случиться, что мяч будет отскакивать не от стены, а от точки, расположенной за ней.

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

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

Когда все 16 кирпичей выбиты, уровень пройден. На следующем уровне шар движется несколько быстрее.
в том, чтобы создать противника,
Задача проекта
Цель игры состоит в том, чтобы создать противника, обладающего искусственным интеллектом, с которым будет соревноваться игрок. Левая бита будет управляться игроком, а правая - воссоздавать возможную реакцию человека с помощью компьютерных расчетов.
Мяч будет отскакивать от верхней и нижней стен, и только от действий игрока и компьютера будет зависеть, вылетит ли он за пределы экрана.
Когда мяч пролетает мимо одной из бит игроков, игра приостанавливается до тех пор, пока пользователь не щелкнет по кнопке "serve". Затем мяч снова появится в середине экрана. Счет игры сохранится. Игра заканчивается в том случае, если один из игроков наберет 7 очков.