Рекурсивные блоки

Исходный файл: Blocks.fla

Я встречал эту игру в разных вариациях под разными названиями. Основная идея ее в том, что экран заполнен большой решеткой, состоящей из цветных блоков. Игрок может нажать на блок, чтобы удалить его из решетки. Но чтобы удаление блока стало возможным, он должен иметь сверху, снизу или рядом соседний блок того же цвета.
Когда игрок нажимает на доступный для удаления блок, он убирается. К тому же, убирается и соседний блок того же цвета. Все соседи одного цвета с удаленным блоком удаляются тоже. Таким образом, связанная область блоков одного цвета может быть удалена нажатием на любой из блоков этой области.
После удаления группы блоков их верхние соседи спускаются вниз на освободившиеся места. Если какая-нибудь колонка блоков оказывается совершенно пустой, решетка сдвигается влево, чтобы заполнить свободные места.
На рис. 14.8 показано начало игры. В добавление к одному из четырех цветов я поместил на каждый блок маленький рисунок, соответствующий цвету блока. Это облегчает распознавание блоков на черно-белом рисунке. Единственный способ действительно понять игру- это сыграть в нее, поэтому сделайте это прямо сейчас, прежде чем продолжать читать дальше.

Рисунок 14.8 Игра "Рекурсивные блоки" начинается со случайной решетки цветных блоков

Задача проекта

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

Подход

Решетка представляет собой серию клипов, созданных с помощью Action-Script. Когда пользователь щелкает по блоку, он удаляется из решетки после того, как отмечен его цвет. Потом каждый из его четырех соседей подвергается проверке, не того же ли он цвета. Если не того же, удаленный блок восстанавливает свой исходный цвет.
Метод удаления блоков является рекурсивным. Каждый сосед выделенного курсором блока проверяется, какого он цвета. Если того же; проверяется каждый его сосед, и т. д. Этот рекурсивный метод в конце концов находит блок, который не имеет соседей того же цвета, и рекурсия заканчивается.
Если вы не вполне уверены, что понимаете, как работает эта рекурсия, посмотрите пример шаг за шагом. Например, пользователь щелкнул по красному блоку. Из четырех его соседей блок сверху и блок справа тоже красные. Возьмите блок сверху. Среди его соседей нет красных блоков. Возьмите блок справа. Блок снизу от него тоже красный. Возьмите этот третий красный блок. Среди его соседей нет красных блоков. Таким образом, блок, по которому пользователь щелкнул, удаляется. Удаляется также блок сверху, блок справа и блок снизу от блока справа.
Хотя игра не определяет, сделал ли пользователь все возможное, она присуждает очки. Лучший способ определения очков в подобной игре -это экспоненциальная система присуждения очков. Таким образом, если удаляется группа из двух блоков, игрок получает 4 очка: 2 раза по 2. Если удаляется группа из 3 блоков, игрок получает 3 раза по 3, или 9 очков. Если же удаляется группа из 4 блоков, игрок получает 4 раза по 4, или 16 очков.
Эта система подсчета очков поощряет игрока находить большие группы блоков. Например, удаление 10 групп по 2 блока принесет пользователю 40 очков (2 раза по 2 будет 4, 10 раз по 4 будет 40). Удаление же одной группы из 20 блоков приносит пользователю 400 очков (20 раз по 20). Пользователь должен не только искать большие группы блоков, но пытаться сам их создавать, вытаскивая маленькие группы таким образом, чтобы большие группы пришли в соприкосновение и сформировали еще большую группу.

Подготовка ролика

Ролик содержит довольно мало элементов, за исключением клипа в библиотеке, представляющего блоки. Этот клип содержит 4 кадра, по кадру для каждого цвета. Также в каждом кадре есть маленькая картинка. Пятый кадр пустой и представляет пустое место в решетке. Первые четыре блока имеют кнопку, чтобы по ним можно было щелкнуть. Клипу необходимо присвоить имя в панели Linkage Properties, поскольку он не находится изначально на рабочем поле.
Главная временная шкала ролика включает в себя два кадра: первый, содержащий инструкции и кнопку Play, а второй - это кадр "Play".

Создание кода


Создание блоков происходит в функции startGame. Функция совершает циклы по 20 горизонтальным колонкам и 12 вертикальным рядам и создает 240 блоков. Каждый блок - это новый экземпляр клипа "block", созданного функцией attachMovie. Кроме того, чтобы оказаться в нужном месте рабочего поля, каждый блок обладает свойствами x и у, таким образом, позже он сможет определить свое положение. Выбирается случайное число от 1 до 4, и клип с блоком отправляется к этому кадру.

function startGaine () {
// Переходим к кадру игры.
gotoAndStop("Play");
score = 0;
// Создаем решетку из блоков,
level = 0;
for(var x=0;x<20;x++) {
forlvar y=0;y<12;y++) {
mc = _root.attachMovie("block","block "+x+" "+y,level);
mc._x = 20*x + 85;
mc._y = 20*y + 60;
mс.x = x ;
mс.у = у ;
// Выбираем случайный цвет.
mc.gotoAndStop(Math.ceil(Math.random()*4));
level++;
}}
}

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

on(release) {
_root.clickBlock(x,у);
}

Функция clickBlock определяет цвет блоков и хранит его в переменной Затем блок удаляется (точнее, его клип переходит к пустому кадру). Функция testNeighbor вызывается четыре раза, один раз для каждого соседа. Функция возвращает количество подходящих соседей, найденных в данном направлении. Если, например, сосед сверху того же цвета и три его соседа тоже, возвращается число 4. Добавляя это число к переменной n, вы получаете полное количество блоков в группе.
Если обнаружено, что группа состоит более чем из одного блока, вызываются функции collapseDown и collapseAcross, чтобы удалить все блоки группы. В противном случае выделенный блок возвращается к прежнему цвету, и кажется, что ничего не произошло.

// Произошел щелчок по блоку,
function clickBlock(x,у) {

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

// Определяем цвет этого блока.
var с = _root["block "+x+" "+y]._currentframe;
_root["block "+x+" "+y].gotoAndStop(5);
II Проверяем его соседей по всем направлениям.
var n = 1;
n += testNeighbor(х-1,у,с);
n += testNeighbor(х+1,у,с);
n += testNeighbor(х,у-1,с);
n += testNeighbor(х,у+1,с);
// Если один их них того же цвета,
if (n > 1) {
// Уничтожаем группу блоков.
collapseDown();
collapseAcross();
// Начисляем очки,
score += n*n;
} else {
// Оставляем блок на месте.
_root["block "+x+" "+y].gotoAndStop(с);
}}

Функция testNeighbor проверяет цвет нового блока. Если цвет подходит, блок удаляется. Дальше функция вызывает сама себя и проверяет цвета четырех соседних блоков. Она следит за переменной n, которая определяет количество подходящих соседей.
Если текущий блок не подходит по цвету, вместо n возвращается 0, чтобы показать, что в этом направлении не было найдено ни одного подходящего блока.

function testNeighbor(x,у,с) {
if (_root["block "+x+" "+y]._current frame = = с) {
// Удаляем соседа.
_root [ "block "+x+""+y].gotoAndStop(5);
var n = 1;
// Проверяем всех его соседей,
n += testNeighbor(x-1,y,с);
n += testNeighbor(х+1,у,с);
n += testNeighbor(х,у-1,с);
n += testNeighbor(x,y+l,с);
// Возвращаем количество найденных соседей,
return(n);
} else {
// Не найдено никаких подходящих блоков.
return(0);
}}

После того как блок выбран и все соседи одного с ним цвета удалены, следующий шаг - это позволить всем оставшимся блокам упасть вниз на все свободные места. Это достигается прохождением по всем столбцам в цикле по переменной х. Затем, во вложенном цикле по у происходит проверка всех блоков в этом столбце снизу вверх. И если блок пустой, первый заполненный блок сверху смешается вниз.

function collapseDown() {
// Проходим по всем столбцам.
for(var x=0;x<20;x++) {
// Проходим по всем блокам столбца снизу вверх.
for(var y=11;y>0;y--) {
// Смотрим, пустой ли блок.
thisColor = _root["block "+x+'"+y]._currentFrame;
if (thisColor == 5) {
// Если да, просматриваем все блоки над ним.
for(var i=y-1;i> = 0;i —- ) {
// Если блок не пустой.
aboveCoior = _root[ "block "+x+" ,"+i] ._currentframe;
if (aboveCoior != 5) {
// Смещаем его вниз.
_root["block "+x+""+y].gotoAndStop(aboveCoior);
_root["block "+x+" "+i].gotoAndStop(5)
break;
}}}}}}

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

function collapseAcross() {
// Продолжаем, пока есть пустые столбцы,
do {
n = 0;
// Проверяем все столбцы,
for(var x=0;x<19;x++) {
// Если текущий столбец пустой.
if (_root["block "+x+" 11"]._currentframe = = 5) {
// Если следующий - полный, if (_root["block "+(x+1)+" 11"] _currentframe != 5)
{ n++;
// Смещаем все блоки.
for(var у=0,-у<12;у++){
c = _root["block "+(x+1)+" "+y]._currentframe;
_root["block "+x+" "+y].gotoAndStop(c);
_root["block "+(x+1)+" "+y].gotoAndStop(5);
}}}}
// цикол прекращается, если больше не обнаружено пустых столбцов
} while (n > 0);
}

К сведению

В игре имеется поле score, помешенное под игровой областью. Оно отслеживает переменную score, которая увеличивается в процессе исполнения функции clickBlock.

Другие возможности

Один момент в этой игре пропущен - способ узнавать, когда игра закончилась. Вы можете поместить кнопку "I'm Done!" в кадре и дать возможность игроку решать, когда игра закончена.
Однако можно использовать ActionScript, чтобы определить два возможных пути завершения игры. Первый, это когда все блоки удалены. Это редкость; большинство игр оставляют несколько неудаляемых блоков. Но, если это случится, вы можете определить это, выясняя, не пуст ли самый нижний левый блок после того, как функция collapseDown запушена.

if (_root["block 0 11"]._currentFrame == 5) {
gotoAndStop("gameOver");
}

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