Поиск пути в лабиринте

• 1. Техническое задание
• 1.1 Основания для разработки
• 1.2 Назначение разработки
• 1.3 Требования к программной документации
• 1.4 Порядок приемки и контроля
• 1.5 Тесты
• 2. Технический проект
• 2.1 Диаграмма классов
• 3. Рабочий проект
• 3.1 Общее описание программы
• 3.2 Описание подпрограмм класса leaf
• 3.3 Описание подпрограмм класса TForm1
• 3.4 Описание подпрограмм класса TForm2
• Список использованных источников
• Приложение

1. Техническое задание

1.1 Основания для разработки

Основанием для разработки программного продукта служит задание по курсовой работе по дисциплине «Структуры и алгоритмы обработки данных» .

1.2 Назначение разработки

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

Рассмотренные альтернативы

При постановке задачи на разработку данного программного изделия была выбрана среда разработки Borland C++Builder 6 в силу легкости проектирования пользовательского интерфейса.

Стандарты

Разработка программной документации и программного изделия должна производиться согласно ГОСТ 19.701−90, ГОСТ 2.304−88. Единая система программной документации.

Требования пользователя к программному изделию

Функциональные требования

· Система должна представлять собой одну программу.

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

· В каждой комнате лабиринта должно храниться количество монет, от одной до ста.

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

Программные ограничения, совместимость

Программное изделие должно работать в операционных системах Windows. Для переноса программы не должны требоваться специальные программные и аппаратные средства.

Носители информации

Программное изделие будет размещено в виде исполняемого файла на диске CD-R, либо на жестком диске, либо на flash-носителе.

Входные данные

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

Выходные данные

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

Процессы обработки

В процессе работы программа создает массив структур komnat. Каждая структура может быть либо комнатой, либо стеной. С помощью алгоритма генерации создается соответствующий условиям лабиринт и случайным образом выбираются комнаты, в которых находится входная дверь и выходная дверь. Алгоритм поиска пути формирует дерево, корень которого соответствует входной комнате, а ветви — соседних комнатам, к которым есть доступ. Если в процессе поиска ветка достигла выходной комнаты, то путь размечается, а собранные сокровища суммируются и выводятся. Алгоритм поиска завершается, когда обработаны все ветви, в связи с чем время поиска увеличивается пропорционально количеству дверей между комнатами.

Рестарт

В случаях рестарта необходимо запустить на выполнение программу. Данные при рестарте не сохраняются

Требования к составу и параметрам технических средств

Для работы программного модуля необходимо дисковое пространство в размере не менее 300 Кб, свободная оперативная память в размере не менее 12 Мб, разрешение экрана не менее 1024×768, также микропроцессор 80 486 или выше.

Результирующие компоненты изделия

Файл программы LABIRINT. exe.

1.3 Требования к программной документации

Программная документация должна включать следующие документы:

1) техническое задание;

2) рабочий проект;

3) приложение (листинг исходных текстов программного изделия).

1.4 Порядок приемки и контроля

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

программный пользователь borland builder

1.5 Тесты

Тест № 1

Действия: запуск программы.

Реакция программы: появляется главное окно приветствия (см. рисунок 1.1).

Рисунок 1.1 Тест № 1

Тест № 2

Действия: клик мышью в окне приветствия.

Реакция программы: появляется главное окно со сгенерированным лабиринтом и начинается процесс поиска пути (см. рисунок 1.2).

Тест № 3

Действия: клик мышью по лабиринту с найденным путем.

Реакция программы: генерируется новый лабиринт и начинается процесс поиска пути (см. рисунок 1.2), во время которого лабиринт по необходимости перерисовывается. При окончании процесса поиска выводятся сообщения: в случае неудачного поиска о необходимости перестроить лабиринт (см. рисунок 1.3), а в случае успешного поиска с информацией о найденном пути (см. рисунок 1.4, 1.5).

Рисунок 1.2 Тест № 2,3

Рисунок 1.3 Тест № 3

Рисунок 1.4 Тест № 3

Рисунок 1.5 Тест № 3

Тест № 4

Действия: нажатие кнопки «Пробел»

Реакция программы: с каждым нажатием кнопки изменяется режим отображения информации в заголовке программы и режим отрисовки лабиринта (см. рисунок 1.2, 1.6, 1.7).

Рисунок 1.4 Тест № 6

Рисунок 1.4 Тест № 7

Тест № 5

Действия: нажатие кнопки Escape во время поиска пути.

Реакция программы: процесс поиска пути досрочно завершается и выводится информация (см. рисунок 1.3, 1.4, 1.5).

2. Технический проект

2.1 Диаграмма классов

3. Рабочий проект

3.1 Общее описание программы

Данное программное изделие состоит из 2 модулей. В программном изделии используются методы работы с графическим объектом TCanvas. Информация поступает с клавиатуры и мыши.

3.2 Описание подпрограмм класса leaf

Конструктор leaf: leaf ()

Входные данные: нет.

Выходные данные: нет.

Процессы обработки: выделяется память для ветвей текущего узла дерева поиска пути.

Используемые внешние переменные: kids.

Подпрограмма bool leaf: IsVisited (int x, int y, leaf* obj)

Входные данные: int x, int y — координаты проверяемой комнаты, leaf* obj — указатель на проверяемый узел дерева.

Выходные данные: булева переменная.

Процессы обработки: рекурсивно проверяются все комнаты, начиная с текущей и заканчивая входной комнатой, с помощью указателя obj->parent. Если в цепочке предыдущих комнат нашлась комната с координатами x и у, то возвращаем true, иначе возвращаем false.

Используемые внешние переменные: нет.

Подпрограмма void leaf: SetNewLeaf (leaf *obj, int n)

Входные данные: указатель на узел дерева leaf* obj, номер узла int n.

Выходные данные: нет.

Процессы обработки: выделяется память для нового узла дерева.

Используемые внешние переменные: нет.

Подпрограмма void leaf: Tracing (leaf* obj, int n)

Входные данные: указатель на узел последней комнаты leaf* obj, номер комнаты int n.

Выходные данные: нет.

Процессы обработки: комната в массиве лабиринта с координатами из узла дерева поиска obj отмечается номером n и рекурсивно отмечается предыдущий узел в дереве.

Используемые внешние переменные: массив комнат лабиринта a.

Подпрограмма void leaf: GrowTree (TPoint p, leaf* obj)

Входные данные: указатель на узел дерева leaf* obj, координаты комнаты TPoint p.

Выходные данные: нет.

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

Используемые внешние переменные: массив комнат лабиринта a.

3.3 Описание подпрограмм класса TForm1

Подпрограмма void __fastcall TForm1: Image1Click (TObject *Sender)

Входные данные: указатель на вызывающий объект.

Выходные данные: нет.

Процессы обработки: окно приветствия скрывается и появляется главное окно.

Используемые внешние переменные: нет.

3.4 Описание подпрограмм класса TForm2

Подпрограмма void CreateLabirint ()

Входные данные: нет.

Выходные данные: нет.

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

Используемые внешние переменные: массив комнат лабиринта a, координаты входной и выходной комнат A и B.

Подпрограмма void Draw ()

Входные данные: нет.

Выходные данные: нет.

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

Используемые внешние переменные: графический буфер buffer, режим отображения int info, массив комнат лабиринта a.

Подпрограмма void InNul ()

Входные данные: нет.

Выходные данные: нет.

Процессы обработки: номера всех комнат лабиринта обнуляются.

Используемые внешние переменные: массив комнат лабиринта a.

Подпрограмма void __fastcall TForm2: FormKeyPress (TObject *Sender, char &Key)

Входные данные: ссылка на нажатую клавишу &Key, указатель на вызывающий объект *Sender.

Выходные данные: нет.

Процессы обработки: обрабатывается нажатая клавиша. При клавише «Пробел» режим отображения циклически меняется, при клавише «Escape» процесс поиска пути прерывается. После нажатия лабиринт перерисовывается.

Используемые внешние переменные: режим отображения int info, булева переменная — запущен ли процесс поиска пути — bool process.

Подпрограмма void __fastcall TForm2: FormCloseQuery (TObject *Sender, bool &CanClose)

Входные данные: ссылка на булеву переменную — возможность закрытия окна программы — &CanClose, указатель на вызывающий объект *Sender.

Выходные данные: нет.

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

Используемые внешние переменные: булева переменная — запущен ли процесс поиска пути — bool process.

Подпрограмма void __fastcall TForm2: FormClose (TObject *Sender, TCloseAction &Action)

Входные данные: ссылка на выполняемое действие &Action, указатель на вызывающий объект *Sender.

Выходные данные: нет.

Процессы обработки: приложения закрывается.

Используемые внешние переменные: нет.

Подпрограмма void __fastcall TForm2: FormClick (TObject *Sender)

Входные данные: указатель на вызывающий объект *Sender.

Выходные данные: нет.

Процессы обработки: запускается процесс поиска пути, после которого выводятся сообщения об удачном или неудачном результате поиска.

Используемые внешние переменные: корень поискового дерева root, булевы переменные — флаг запуска процесса поиска process, флаг прерывания процесса поиска newprocess, количество максимально собранных сокровищ — int max, массив комнат лабиринта a.

Подпрограмма void __fastcall TForm2: FormCreate (TObject *Sender)

Входные данные: указатель на вызывающий объект *Sender.

Выходные данные: нет.

Процессы обработки: изменяется размеры графического буфера и перерисовывается лабиринт.

Используемые внешние переменные: графический буфер buffer.

Список использованных источников

1 Мозговой М. В. Занимательное программирование. Самоучитель. 1-е изд. [Текст] - СПб.: Питер, 2004. — 208 с.

2 Культин Н. Б. C/C++ и в задачах и примерах. 2-е издание. [Текст] - СПб.: БХВ — Петербург, 2011. — 368 с.

3 Архагельский А. Я. Программирование в С++ Builder 6. [Текст] - М.: Бином, 2008. — 1152 с.: ил.

4 Ахо А. В., Хопкрофт Д. Э., Ульман Д. Д. Структуры данных и алгоритмы. [Текст] - СПб.: Вильямс, 2000. — 382 с.: ил.

Приложение

Листинг файла Unit1. cpp

// —————————————————————————————————————;

#include

#pragma hdrstop

#include «Unit1. h»

#include «Unit2. h»

// —————————————————————————————————————;

#pragma package (smart_init)

#pragma resource «*. dfm»

TForm1 *Form1;

// —————————————————————————————————————;

__fastcall TForm1: TForm1 (TComponent* Owner)

: TForm (Owner)

{

}

// —————————————————————————————————————;

void __fastcall TForm1: Image1Click (TObject *Sender)

{

Form1->Visible = false;

Form2->Visible = true;

Form2->Show ();

Form2->SetFocus ();

Form2->FormClick (Form2);

}

// —————————————————————————————————————;

Листинг файла Unit2. cpp

// —————————————————————————————————————;

#include

#pragma hdrstop

#include «Unit1. h»

#include «Unit2. h»

// —————————————————————————————————————;

#pragma package (smart_init)

#pragma resource «*. dfm»

TForm2 *Form2;

// структура одной комнаты

struct komnata{

// является ли комната проходной или нет

bool stena;

// сокровища

int sokrovihe;

// номер комнаты в находимом пути

int number;

};

// структура узла дерева (комнаты), строящегося для нахождения пути

struct leaf{

// точка, ее координаты — это номер комнаты

// по горизонтали и вертикали

TPoint id;

// сколько денег накапливается до этой комнаты

int mone;

// указатель на предыдущую комнату

leaf* parent;

// указатели на соседние комнаты

leaf** kids;

// конструктор узла

leaf () {

// выделяется память для соседних комнат

kids = new leaf* [4];

for (int i=0; i<4; i++)

kids [i] =NULL;

}

bool IsVisited (int x, int y, leaf* obj);

void SetNewLeaf (leaf *obj, int n);

void Tracing (leaf* obj, int n);

void GrowTree (TPoint p, leaf* obj);

};

// размерность лабиринта

const int N = 15;

// массив из комнат

komnata a [N] [N];

// максимальное значение накопленных сокровищ

int max = 0;

// режим отображения информации

int info = 0;

// указатель на корень поискового дерева

leaf* root = NULL;

// точки — координаты комнат входа и выхода

TPoint A, B;

// был ли запущен процесс поиска пути

bool process = false;

// был ли прерван процесс поиска пути

bool newprocess = false;

// графический буфер для отрисовки лабиринта

Graphics: TBitmap *buffer = new (Graphics: TBitmap);

// —————————————————————————————————————;

__fastcall TForm2: TForm2 (TComponent* Owner)

: TForm (Owner)

{

}

// —————————————————————————————————————;

// функция создания лабиринта

void CreateLabirint ()

{

// создаем везде стены

for (int i=0; i<=N; i++)

for (int j=0; j<=N; j++) {

a [i] [j]. stena = true;

a [i] [j]. sokrovihe=random (99) +1;

a [i] [j]. number=0; }

// текущая комната и направление движения

int x, y, c;

// делаем N/2 циклов создания коридоров

for (int i=0; i<=N/2; i++) {

// выбираем случайную комнату внутри лабиринта

x = random (N-2) +1;

y = random (N-2) +1;

// выбираем случайное направление движения

c = random (4);

// выбираем случайное количество поворотов коридора

for (int d = random (3) +2; d>=0; d—) {

// выбираем случайное количество комнат до поворота

for (int k = random (3) +2; k>=0; k—) {

switch © {

// переходим в одну из четырех сторон

case 0: x++; break;

case 1: y++; break;

case 2: x—; break;

case 3: y—; break; }

// самые крайние комнатамы не делаем

if (x<=0||y<=0||x>=N-2||y>=N-2) break;

a [x] [y]. stena = false; }

// переходим на другое направление

c = (c+1) %4; }}

// случайно выбираем комнату, от которой будем строить путь

A. x=0; A. y=0;

while (A. x==0&&A. y==0)

if (a [x=random (N)] [y=random (N)]. stena==false)

{A. x=x; A. y=y; };

// случайно выбираем комнату, до которой будем строить путь

B. x=0; B. y=0;

while (B. x==0&&B. y==0)

if (a [x=random (N)] [y=random (N)]. stena==false)

{B. x=x; B. y=y; };

}

// функция отрисовки лабиринта

void Draw ()

{

// размеры сетки лабиринта по горизонтали и вертикали

int n=buffer->Height/N;

int m=buffer->Width/N;

// закрашиваем нарисованное до этого

buffer->Canvas->Brush->Color = clWhite;

buffer->Canvas->Pen->Color = clWhite;

buffer->Canvas->Rectangle (0,0,buffer->Width, buffer->Height);

// проходим двойным циклом по массиву комнат

for (int i=0; i

for (int j=0; j

// если это стена, то закрашиваем ее черным прямоугольником

if (a [i] [j]. stena) {

buffer->Canvas->Pen->Color = clBlack;

buffer->Canvas->Brush->Color = clBlack;

buffer->Canvas->Rectangle (i*m, j*n, i*m+m, j*n+n);

}else{

// если это комната, то в зависимости от режима отображения рисуем по-разному

switch (int inf=info) {

// выводим полную информацию:

case (0): {

buffer->Canvas->Brush->Color = clWhite;

buffer->Canvas->Font->Color = clRed;

// если это комната входа, то закрашиваем ее желтым

if (i==A. x&&j==A. y) {

buffer->Canvas->Brush->Color = clYellow;

buffer->Canvas->Pen->Color = clYellow;

buffer->Canvas->Font->Color = clBlack;

buffer->Canvas->Rectangle (i*m, j*n, i*m+m, j*n+n); }

// если это комната выхода, то закрашиваем ее голубым

if (i==B. x&&j==B. y) {

buffer->Canvas->Brush->Color = clSkyBlue;

buffer->Canvas->Pen->Color = clSkyBlue;

buffer->Canvas->Font->Color = clBlack;

buffer->Canvas->Rectangle (i*m, j*n, i*m+m, j*n+n); }

// выводим в верхнем левом углу количество монет, которое можно забрать в этой комнате

buffer->Canvas->TextOutA (i*m+1,j*n+1, IntToStr (a [i] [j]. sokrovihe));

// если через эту комнату не ведет путь, то уходим

if (a [i] [j]. number==0) continue;

// иначе запоминаем номер комнаты в пути

String s=IntToStr (a [i] [j]. number);

// запоминаем его размеры при отрисовке

int I=i*m+m-buffer->Canvas->TextWidth (s);

int J=j*n+n-buffer->Canvas->TextHeight (s);

buffer->Canvas->Brush->Color = clLime;

buffer->Canvas->Font->Color = clBlack;

// и выводим его на зелёном фоне

buffer->Canvas->TextOutA (I, J, s);

break; }

// режим отображения найденного пути

case 1: {

buffer->Canvas->Brush->Color = clLime;

buffer->Canvas->Pen->Color = clBlack;

buffer->Canvas->Font->Color = clBlack;

// увеличиваем размер шрифта

buffer->Canvas->Font->Size+=3;

// запоминаем размеры надписи

String s=IntToStr (a [i] [j]. number);

int I=buffer->Canvas->TextWidth (s);

int J=buffer->Canvas->TextHeight (s);

// рассчитываем ее координаты, чтобы вывести посередине

int x=i*m+ (m-I) /2;

int y=j*n+ (n-J) /2;

// если эта комната не включена в путь то закрашиваем ее

if (a [i] [j]. number==0)

buffer->Canvas->Brush->Color = clWhite;

buffer->Canvas->Rectangle (i*m, j*n, i*m+m, j*n+n);

// иначе выводим ее номер от входной по порядку

if (a [i] [j]. number! =0)

buffer->Canvas->TextOutA (x, y, s);

buffer->Canvas->Font->Size-=3;

break; }

// вывод информации о сокровищах

case 2: {

buffer->Canvas->Font->Color = clBlack;

buffer->Canvas->Brush->Color = clYellow;

buffer->Canvas->Pen->Color = clBlack;

buffer->Canvas->Font->Size+=3;

// запоминаем размеры выводимой надписи

String s=IntToStr (a [i] [j]. sokrovihe);

int I=buffer->Canvas->TextWidth (s);

int J=buffer->Canvas->TextHeight (s);

int x=i*m+ (m-I) /2;

int y=j*n+ (n-J) /2;

// если комната не включена в путь, то фон делаем белым

if (a [i] [j]. number==0)

buffer->Canvas->Brush->Color = clWhite;

buffer->Canvas->Rectangle (i*m, j*n, i*m+m, j*n+n);

buffer->Canvas->TextOutA (x, y, s);

buffer->Canvas->Font->Size-=3; }

}}

// копируем все нарисованное из буфера в окно программы

Form2->Canvas->CopyRect (TRect (0,0,Form2->Width, Form2->Height),

buffer->Canvas, TRect (0,0,Form2->Width, Form2->Height));

}

// рекурсивная функция проверки посещения комнаты

bool leaf: IsVisited (int x, int y, leaf* obj)

// функция установки нового листа

void leaf: SetNewLeaf (leaf *obj, int n)

{

// выделяем память

obj->kids [n] =new leaf;

// назначаем предыдущую комнату в дереве посещений

obj->kids [n] - >parent = obj;

}

// реверсивная функция разметки пути

void leaf: Tracing (leaf* obj, int n)

{

if (obj! =NULL) {

// отмечаем комнату номером n

a [obj->id. x] [obj->id. y]. number=n;

// и предыдущую комнату номером n-1

Tracing (obj->parent, n+1); }

}

// функция установки номеров всех комнат в 0

void InNul ()

{

for (int i=0; i

for (int j=0; j

a [i] [j]. number=0;

}

// функция поиска пути в лабиринте

// в процессе создается дерево из комнат

void leaf: GrowTree (TPoint p, leaf* obj)

{

// обрабатываем системные сообщения приложения: нажатия мыши, клавиш

Application->ProcessMessages ();

// если был переключен режим

// то меняем заголовок

if (info==1)

Form2->Caption="Обрабатывается комната с координатами «+IntToStr (p. x) +» ," +IntToStr (p. y) +". «;

if (info==2)

if (max! =0)

Form2->Caption="Текущий путь забирает монет: «+IntToStr (max)

+"; через «+IntToStr (a [A. x] [A. y]. number) +» комнат" ;

else

Form2->Caption="Путь еще не найден" ;

// записываем суммарное количество забранных монет

if (obj->parent == NULL)

obj->mone=a [p. x] [p. y]. sokrovihe;

else

obj->mone=obj->parent->mone+a [p. x] [p. y]. sokrovihe;

// записываем координаты текущей комнаты

obj->id = p;

// если текущая — это та, которую нам надо было найти

if (p. x==B. x&&p. y==B. y) {

// если мы еще не записывали максимальное количество монет

// или нашли новый максимальный путь

if (max==0||obj->mone>max) {

// записываем количество монет

max=obj->mone;

// обнуляем все комнаты

InNul ();

// записываем путь

Tracing (obj, 1);

// отрисовываем

Draw ();

}

// удаляем выделенную память

delete [] obj->kids;

delete obj;

// выходим

return;

}

// если мы не отменяли процесс поиска клавишей Escape

// то добавляем ссылки на соседние комнаты

if (! newprocess) {

if (! a [p. x-1] [p. y]. stena&&! IsVisited (p. x-1,p. y, obj))

SetNewLeaf (obj, 0);

if (! a [p. x+1] [p. y]. stena&&! IsVisited (p. x+1,p. y, obj))

SetNewLeaf (obj, 1);

if (! a [p. x] [p. y-1]. stena&&! IsVisited (p. x, p. y-1,obj))

SetNewLeaf (obj, 2);

if (! a [p. x] [p. y+1]. stena&&! IsVisited (p. x, p. y+1,obj))

SetNewLeaf (obj, 3);

// и рекурсивно обрабатываем соседние комнаты

if (obj->kids [0]! =NULL)

GrowTree (TPoint (p. x-1,p. y), obj->kids [0]);

if (obj->kids [1]! =NULL)

GrowTree (TPoint (p. x+1,p. y), obj->kids [1]);

if (obj->kids [2]! =NULL)

GrowTree (TPoint (p. x, p. y-1), obj->kids [2]);

if (obj->kids [3]! =NULL)

GrowTree (TPoint (p. x, p. y+1), obj->kids [3]);

}

// удаляем выделенную память

delete [] obj->kids;

delete obj;

}

// —————————————————————————————————————;

// при нажатии клавиши

void __fastcall TForm2: FormKeyPress (TObject *Sender, char &Key)

{

// если был нажат Пробел, то меняем режим вывода информации

if (Key==VK_SPACE)

info = (info+1) %3;

// если Escape, то устанавливаем переменную, которая досрочно завершит работу

// функции поиска

if (Key==VK_ESCAPE)

newprocess = true;

// при начальном режиме вывода информации

if (info==0)

if (process)

Caption="Производится поиск пути. (вкл/откл информацию — Пробел)" ;

else

Caption="Путь найден (для смены вида — Пробел)" ;

if (! info&&! process)

Caption="Текущий путь забирает монет: «+IntToStr (max)

+"; через «+IntToStr (a [A. x] [A. y]. number) +» комнат" ;

Draw ();

}

// если идет процесс поиска, то нельзя выходить

// —————————————————————————————————————;

void __fastcall TForm2: FormCloseQuery (TObject *Sender, bool &CanClose)

{

if (process) CanClose=false;

}

// —————————————————————————————————————;

// выход из программы

void __fastcall TForm2: FormClose (TObject *Sender, TCloseAction &Action)

{

Application->Terminate ();

}

// —————————————————————————————————————;

// нажатие кнопки мыши

void __fastcall TForm2: FormClick (TObject *Sender)

{

// если процесс поиска уже запущен, то уведовляем и уходим

if (process) {

Caption="Идет поиск. Для остановки нажмите Escape" ;

return; }

// заново создаем лабиринт

newprocess = false;

CreateLabirint ();

// создаем корень дерева

root = new leaf;

root->parent = NULL;

max = 0;

info = 0;

// отрисовываем пусто лабиринт

Draw ();

Caption="Производится поиск пути. (вкл/откл информацию — Пробел)" ;

process = true;

// ищем путь.

root->GrowTree (A, root);

// отрисовываем

Draw ();

// если так и не нвшли

if (max==0) {

Caption="Путь невозможно найти! Лабиринт следует перестроить!" ;

ShowMessage («Путь невозможно найти! Лабиринт следует перестроить!»);

} else {

// если нашли, то выводим сообщения

Caption = «Путь найден!» ;

ShowMessage («Найден путь, проходящий через „+IntToStr (a [A. x] [A. y]. number) +“ комнат»);

ShowMessage («Собрано монет: «+IntToStr (max)); }

process = false;

}

// —————————————————————————————————————;

// устанавливаем размеры графического буфера

void __fastcall TForm2: FormCreate (TObject *Sender)

{

buffer->Width=Form2->Width;

buffer->Height=Form2->Height;

Draw ();

}

// —————————————————————————————————————;