Автоматизированная система построения лабиринта и поиска выхода из него

А.4 Работа с системой

А.4.1 Главное окно приложения

При первом запуске приложения на экране вы увидите главную форму приложения, представленную на рисунке А.1. На ней находятся поле для лабиринта и три области для различных действий:

параметры лабиринта;

вход и выход;

поиск пути.

Рисунок А.1 - Главная форма приложения

При нажатии на кнопку «X» основная форма закрывается.

А.4.2 Установка параметров лабиринта и создание шаблона

Чтобы создать лабиринт в данной программе, необходимо, в первую очередь, выбрать желаемую тему оформления и настроить параметры лабиринта. Для этого в специально отведенных полях нужно задать ширину и высоту будущего лабиринта, и нажать кнопку "Создать шаблон". На поле слева появится сетка заданных размеров, изображенная на рисунке А.2.

Рисунок А.2 - Создание шаблона лабиринта

А.4.3 Расстановка входа и выхода

Расстановка производится по выбору пользователя. Поле для выбора способа расстановки отмечено на рисунке А.3.



Рисунок А.3 - Расстановка входа и выхода

А.4.4 Генерация лабиринта

После расставления входа и выхода необходимо нажать кнопку "Сгенерировать лабиринт". Готовый лабиринт изображен на рисунке А.4.

Рисунок А.4 - Пример генерации лабиринта

А.4.5 Поиск пути

Поиск пути в лабиринте осуществляется в данной программе одним из двух алгоритмов: волновым и "правой руки" (на выбор).

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



Рисунок А.5 - Волновой алгоритм

Путь, найденный с помощью алгоритма "правой руки", изображен на рисунке А.6.

Рисунок А.6 - Алгоритм правой руки

А.4.6 Работа с файлами

В программе предусмотрена возможность сохранения лабиринта в файл и загрузка лабиринта из файла. Найти эти функции можно в пункте меню "Файл", отмеченном на рисунке А.7.



Рисунок А.7 - Пункт меню «Файл»

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

Рисунок А.8 - Ошибка загрузки файла

А.4.7 Справочная информация о системе

При выборе из пункта меню «Справка» пункт «Сведения о системе» открывается справочное окно, содержащее информацию об авторах и документацию. Данное окно изображено на рисунке А.9.



Рисунок А.9 - Справка о системе

При переходе по ссылкам «Создание», «Поиск пути», «Хранение» можно получить соответствующую справочную информацию.



Приложение Б

Листинг программы

// основной класс Лабиринт

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.Drawing;

using System.Windows.Forms;

using System.Diagnostics;

using System.Threading;

using System.IO;

namespace labirint

{

class labirint

{

public int[, ,] lab = new int[100, 100, 3]; // лабиринт: [i,j,0] - ячейки лабиринта, [i,j,1] - для волнового метода - длина волны, для однорукого метода - путь персонажа

public int[,] path = new int[10000, 2]; // обратный путь для волнового метода

public int countpath = 0; // количество шагов в пути волнового метода

public int xcells; // ячеек по горизонтали

public int ycells; // ячеек по вертикали

public int xstart; // координаты стартовой позиции

public int ystart; // координаты стартовой позиции

public int xstop; // координаты конечной позиции

public int ystop; // координаты конечной позиции

public int tx; // текущее положение при одноруком методе

public int ty; // текущее положение при одноруком методе

public int way; // направление движения при одноруком методе

public int len; // текущая длина пути при одноруком методе

public int vert_rating=50; // вероятность в % создания вертикальной стенки в алгоритме Эйлера

public int hor_rating=50; // вероятность в % создания горизонтальной стенки в алгоритме Эйлера

public int state; // текущее состояние лабиринта:

// 0 - пуст, 1 - создан шаблон, 2 - расставлен вход, 3 - расставлены вход/выход, 4 - сгенерирован лабиринт

// 5 - выполняется поиск пути волновым методом, 6 - путь найден волновым методом

// 7 - выполняется поиск пути одноруким методом, 8 - путь найден одноруким методом

// 0 - пуст, 1 - создан шаблон, 2 - расставлены вход/выход, 3 - сгенерирован лабиринт

// генерация лабиринта алгоритмом Эйлера

// Достоинства алгоритма Эйлера:

// 1. отсутствуют зацикливания (имеется только один путь между двумя точками)

// 2. отсутствуют изолированые области

// 3. Из любой точки лабиринта в любую другую точку всегда существует путь

// 3. очень быстр

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

public void generate_eiler()

{

Random rnd = new Random();

int i, j, k, xx, yy, x1, tt, cn, tmn;

int mn = 0;

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

for (i = 1; i < xcells - 1; i++)

{

for (j = 1; j < ycells - 1; j++)

{

lab[i, j, 0] = 0;

}

}

// пройдем по строкам

for (j = 0; j < (ycells - 1) / 2; j++)

{

yy = j * 2 + 1;

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

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

if (lab[xx, yy, 0] == 0)

{

lab[xx, yy, 0] = ++mn;

}

}

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

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

if(lab[xx, yy, 0] == lab[xx+2, yy, 0]) // текущая ячейка и ячейка справа принадлежат одному множеству

{

lab[xx + 1, yy, 0] = 1; // поставим границу между ними

lab[xx + 1, yy+1, 0] = 1;

}

else

{

// решим создавать правую границу между ячейками или нет

tt = rnd.Next(0, 100);

if (tt > vert_rating) // не создаем границу

{

lab[xx+1, yy, 0] = 0;

lab[xx+2, yy, 0] = lab[xx, yy, 0]; // объединим множества

}

else // создаем границу

{

lab[xx + 1, yy, 0] = 1;

lab[xx + 1, yy + 1, 0] = 1;

lab[xx + 1, yy - 1, 0] = 1;

}

}

}

// пройдем слева направо по строке и расставим нижние границы

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

tmn = lab[xx, yy, 0];

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

cn = 0;

for (k = 0; k < (xcells - 1) / 2; k++)

{

x1 = k * 2 + 1;

if ((lab[x1, yy, 0] == tmn) && (lab[x1, yy+1, 0]==0))

{

cn++;

}

}

if (cn > 1) // если в текущем множестве ячейка с нижней границей не одна (больше)

{

// решим создавать нижнюю границу между ячейками или нет

tt = rnd.Next(0, 100);

if (tt > hor_rating) // не создаем границу

{

lab[xx, yy+1, 0] = 0;

}

else // создаем границу

{

lab[xx, yy + 1, 0] = 1;

lab[xx + 1, yy + 1, 0] = 1;

lab[xx - 1, yy + 1, 0] = 1;

}

}

}

// скопируем текущую строку в следующую

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

lab[xx, yy + 2, 0] = lab[xx, yy, 0]; // скопируем ячейки

lab[xx, yy + 3, 0] = lab[xx, yy+1, 0]; // скопируем нижние границы

lab[xx+1, yy + 2, 0] = 0; // удалим все правые границы

if (lab[xx, yy + 3, 0] == 1) // если ячейка имеет нижнюю границу

{

lab[xx, yy + 2, 0] = 0; // удалим ее из множества

}

lab[xx, yy + 3, 0] = 0; // удалим все нижние границы

}

}

// обработка последней строки

yy = ycells - 2;

// скопируем текущую строку в следующую

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

lab[xx, yy, 0] = lab[xx, yy-2, 0]; // скопируем ячейки

lab[xx+1, yy, 0] = lab[xx+1, yy-2, 0]; // скопируем правые границы

lab[xx, yy + 1, 0] = lab[xx, yy - 1, 0]; // скопируем нижние границы

if (lab[xx, yy + 1, 0] == 1) // если ячейка имеет нижнюю границу

{

lab[xx, yy, 0] = ++mn; // отнесем ее к новому множеству

}

}

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

// если текущая ячейка и ячейка справа члены разных множеств

if (lab[xx, yy, 0] != lab[xx + 2, yy, 0])

{

// удалим правую границу

lab[xx + 1, yy, 0] = 0;

// объединим множества

tmn = lab[xx + 2, yy, 0];

tt = lab[xx, yy, 0];

cn = 0;

for (k = 0; k < (xcells - 1) / 2; k++)

{

x1 = k * 2 + 1;

if (lab[x1, yy, 0] == tmn)

{

lab[x1, yy, 0] = tt;

}

}

}

}

// очистим проходы

for (j = 0; j < (ycells - 1) / 2; j++)

{

yy = j * 2 + 1;

for (i = 0; i < (xcells - 1) / 2; i++)

{

xx = i * 2 + 1;

lab[xx, yy, 0] = 0;

}

}

// восстановим границы по периметру

for (i = 0; i < xcells; i++)

{

lab[i, 0, 0] = 1;

lab[i, ycells - 1, 0] = 1;

}

for (i = 0; i < ycells; i++)

{

lab[0, i, 0] = 1;

lab[xcells - 1, i, 0] = 1;

}

lab[xstart-1, ystart-1, 0] = 2;

lab[xstop-1, ystop-1, 0] = 3;

// с соседней (с входом) ячейки уберем стенку

if (xstart == 1) lab[xstart, ystart - 1, 0] = 0;

if (ystart == 1) lab[xstart - 1, ystart, 0] = 0;

if (xstart == xcells) lab[xstart - 2, ystart - 1, 0] = 0;

if (ystart == ycells) lab[xstart - 1, ystart - 2, 0] = 0;

// с соседней (с выходом) ячейки уберем стенку

if (xstop == 1) lab[xstop, ystop - 1, 0] = 0;

if (ystop == 1) lab[xstop - 1, ystop, 0] = 0;

if (xstop == xcells) lab[xstop - 2, ystop - 1, 0] = 0;

if (ystop == ycells) lab[xstop - 1, ystop - 2, 0] = 0;

}

// Волновой алгоритм

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

public void Volna()

{

int i, j;

// элементы массива lab[i,j,1] содержат значение длины волны лабиринта

// инициализируем их значениями -1

for (i = 0; i < xcells; i++)

{

for (j = 0; j < ycells; j++)

{

lab[i, j, 1] = -1;

}

}

lab[xstart - 1, ystart - 1, 1] = 0; // на входе в лабиринт длина волны =0

int lastwave = -1; // номер текущей волны

int cou = 1; // количество ячеек, которые накрыла предыдущая волна

bool found = false; // волна достала до выхода?

while (!found && (cou > 0)) // пока волна не дошла до выхода и пока предыдущая волна накрыла хоть сколько-нибудь ячеек

{

cou = 0; // количество ячеек, которые накрыла волна

lastwave++; // номер текущей волны

for (i = 0; i < xcells; i++)

{

for (j = 0; j < ycells; j++)

{

if (lab[i, j, 1] == lastwave) // обработаем только ячейки, которые накрыло предыдущей волной

{

// если

// существует ячейка сверку от текущей

// никакая предыдущая волна ее не накрывала

// и в этой ячейке не стена

if ((j > 0) && (lab[i, j - 1, 1] < 0) && (lab[i, j - 1, 0] != 1))

{

lab[i, j - 1, 1] = lastwave + 1; // накрываем эту ячейку следующей волной

cou++; // количество ячеек, которые накрыла волна

// если накрытая волной ячейка это выход, то включаем признак того, что волна достигла выхода

if (lab[i, j - 1, 0] == 3) found = true;

// на ячейке напишем номер волны, которой ее накрыло

/// gfr.DrawString(Convert.ToString(lastwave + 1), new Font("Tahoma", 8), Brushes.Gray, new Point((int)i * sizecell + sizecell / 3, (int)(j - 1) * sizecell + sizecell / 3));

}

// если

// существует ячейка снизу от текущей

// никакая предыдущая волна ее не накрывала

// и в этой ячейке не стена

if ((j < ycells - 1) && (lab[i, j + 1, 1] < 0) && (lab[i, j + 1, 0] != 1))

{

lab[i, j + 1, 1] = lastwave + 1; // накрываем эту ячейку следующей волной

cou++; // количество ячеек, которые накрыла волна

// если накрытая волной ячейка это выход, то включаем признак того, что волна достигла выхода

if (lab[i, j + 1, 0] == 3) found = true;

// на ячейке напишем номер волны, которой ее накрыло

/// gfr.DrawString(Convert.ToString(lastwave + 1), new Font("Tahoma", 8), Brushes.Gray, new Point((int)i * sizecell + sizecell / 3, (int)(j + 1) * sizecell + sizecell / 3));

}

// если

// существует ячейка слева от текущей

// никакая предыдущая волна ее не накрывала

// и в этой ячейке не стена

if ((i > 0) && (lab[i - 1, j, 1] < 0) && (lab[i - 1, j, 0] != 1))

{

lab[i - 1, j, 1] = lastwave + 1; // накрываем эту ячейку следующей волной

cou++; // количество ячеек, которые накрыла волна

// если накрытая волной ячейка это выход, то включаем признак того, что волна достигла выхода

if (lab[i - 1, j, 0] == 3) found = true;

// на ячейке напишем номер волны, которой ее накрыло

/// gfr.DrawString(Convert.ToString(lastwave + 1), new Font("Tahoma", 8), Brushes.Gray, new Point((int)(i - 1) * sizecell + sizecell / 3, (int)j * sizecell + sizecell / 3));

}

// если

// существует ячейка справа от текущей

// никакая предыдущая волна ее не накрывала

// и в этой ячейке не стена

if ((i < xcells - 1) && (lab[i + 1, j, 1] < 0) && (lab[i + 1, j, 0] != 1))

{

lab[i + 1, j, 1] = lastwave + 1; // накрываем эту ячейку следующей волной

cou++; // количество ячеек, которые накрыла волна

// если накрытая волной ячейка это выход, то включаем признак того, что волна достигла выхода

if (lab[i + 1, j, 0] == 3) found = true;

// на ячейке напишем номер волны, которой ее накрыло

/// gfr.DrawString(Convert.ToString(lastwave + 1), new Font("Tahoma", 8), Brushes.Gray, new Point((int)(i + 1) * sizecell + sizecell / 3, (int)j * sizecell + sizecell / 3));

}

}

}

}

/// pictureBox1.Refresh(); // обновить изображение pictureBox1 на форме

/// Thread.Sleep(100); // сделаем паузу на указанное количество миллисекунд

}

if (!found) // не найден выход - никакая воолна не накрыла ячейку с выходом

{

// выводим сообщение и выходим

MessageBox.Show("В лабиринте НЕ существует пути от входа до выхода!");

return;

}

/// pictureBox1.Refresh(); // обновить изображение pictureBox1 на форме

// путь имеется!

// найдем кратчайшее расстояния, перемещаясь от выхода к входу

// текущая ячейка при обратном поиске

tx = xstop - 1;

ty = ystop - 1;

countpath = 0;

path[countpath,0]=tx;

path[countpath,1]=ty;

countpath++;

lastwave = lab[tx, ty, 1];

while (lastwave > 0) // пока не дошли до входа (у него номер волны =0)

{

/// pictureBox1.Refresh(); // обновить изображение pictureBox1 на форме

/// Thread.Sleep(70); // сделаем паузу на указанное количество миллисекунд

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

/// gfr.DrawString(Convert.ToString(lastwave), new Font("Tahoma", 8), Brushes.Red, new Point((int)tx * sizecell + sizecell / 3, (int)ty * sizecell + sizecell / 3));

// далее идет проверка соседних ячеек и поиск ячейки у которой длина волны на 1 меньше текущего значения волны

// проверяем ячейку сверху

if ((ty > 0) && (lab[tx, ty - 1, 1] == lastwave - 1))

{

// нарисуем красную линию (путь) от текущей ячейки до соседней

/// gfr.DrawLine(Pens.Red, (int)tx * sizecell + sizecell / 2, (int)ty * sizecell + sizecell / 2, (int)tx * sizecell + sizecell / 2, (int)(ty - 1) * sizecell + sizecell / 2);

path[countpath, 0] = tx;

path[countpath, 1] = ty-1;

countpath++;

ty--; // изменяем текущую ячейку

lastwave--; // уменьшаем длину волны

continue; // переходим к следующей итерации цикла

}

// проверяем ячейку снизу

if ((ty < ycells - 1) && (lab[tx, ty + 1, 1] == lastwave - 1))

{

// нарисуем красную линию (путь) от текущей ячейки до соседней

/// gfr.DrawLine(Pens.Red, (int)tx * sizecell + sizecell / 2, (int)ty * sizecell + sizecell / 2, (int)tx * sizecell + sizecell / 2, (int)(ty + 1) * sizecell + sizecell / 2);

path[countpath, 0] = tx;

path[countpath, 1] = ty + 1;

countpath++;

ty++; // изменяем текущую ячейку

lastwave--; // уменьшаем длину волны

continue; // переходим к следующей итерации цикла

}

// проверяем ячейку слева

if ((tx > 0) && (lab[tx - 1, ty, 1] == lastwave - 1))

{

// нарисуем красную линию (путь) от текущей ячейки до соседней

/// gfr.DrawLine(Pens.Red, (int)tx * sizecell + sizecell / 2, (int)ty * sizecell + sizecell / 2, (int)(tx - 1) * sizecell + sizecell / 2, (int)ty * sizecell + sizecell / 2);

path[countpath, 0] = tx - 1;

path[countpath, 1] = ty;

countpath++;

tx--; // изменяем текущую ячейку

lastwave--; // уменьшаем длину волны

continue; // переходим к следующей итерации цикла

}

// проверяем ячейку справа

if ((tx < xcells - 1) && (lab[tx + 1, ty, 1] == lastwave - 1))

{

// нарисуем красную линию (путь) от текущей ячейки до соседней

/// gfr.DrawLine(Pens.Red, (int)tx * sizecell + sizecell / 2, (int)ty * sizecell + sizecell / 2, (int)(tx + 1) * sizecell + sizecell / 2, (int)ty * sizecell + sizecell / 2);

path[countpath, 0] = tx + 1;

path[countpath, 1] = ty;

countpath++;

tx++; // изменяем текущую ячейку

lastwave--; // уменьшаем длину волны

continue; // переходим к следующей итерации цикла

}

}

/// pictureBox1.Refresh(); // обновить изображение pictureBox1 на форме

}

// Алгоритм одной руки. Отвечает на вопрос: можно ли переместиться в указанную ячейку?

public bool can(int tox, int toy)

{

if ((tox < 0) || (tox > xcells - 1) || (toy < 0) || (toy > ycells - 1)) return false;

if (lab[tox, toy, 0] == 1) return false;

return true;

}

// Сделать следующий шаг

// Используется в Алгоритме одной руки.

public bool NextStep()

{

int w0 = way; // направление, в сторону которого смотрим 1-вверх 2-вправо 3-вниз 4-влево

int px = 0; // смещение по горизонтали

int py = 0; // смещение по вертикали

do // просмотрим все вокруг

{

if (w0 == 1) { px = 0; py = -1; } // если направление вверх, корректируем смещения

if (w0 == 2) { px = 1; py = 0; } // если направление вправо, корректируем смещения

if (w0 == 3) { px = 0; py = 1; } // если направление вниз, корректируем смещения

if (w0 == 4) { px = -1; py = 0; } // если направление влево, корректируем смещения

if (can(tx + px, ty + py)) break; // если в ячейку со смещением возможен переход, то покидаем цикл

else w0--; // иначе поворачиваемся против часовой стрелки

if (w0 < 1) w0 = 4; // если направление ушло из диапазона 1-4 - возвращаем его в этот диапазон

} while (w0 != way); // пока все вокруг не просмотрели

if (can(tx + px, ty + py)) // если в ячейку со смещением возможен переход

{

if (lab[tx + px, ty + py, 1] > 0)

{

if (lab[tx, ty, 1] > lab[tx + px, ty + py, 1])

{

lab[tx, ty, 1] = 0;

len = lab[tx + px, ty + py, 1];

}

}

else

{

len++;

lab[tx + px, ty + py, 1] = len;

}

// корректируем текущее положение персонажа

tx = tx + px;

ty = ty + py;

// lab[tx, ty, 1] = 1; // пометим след от персонажа

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

way = w0 + 1;

if (way > 4) way = 1; // если направление ушло из диапазона 1-4 - возвращаем его в этот диапазон

for (int i = 1; i < xcells - 1; i++)

{

for (int j = 1; j < ycells - 1; j++)

{

if (lab[i, j, 1] > len) lab[i, j, 1] = 0;

}

}

return true; // да, следующий шаг сделан успешно

}

else return false; // нет, следующий шаг сделать не удалось

}

// Сохранение лабиринта в файл

public void Save()

{

int ts = 0;

SaveFileDialog saveFileDialog1 = new SaveFileDialog(); // создаем системный диалог сохранения файла

// задаем ему необходимые параметры (свойства)

saveFileDialog1.Filter = "Labyrint files (*.lab)|*.lab";

saveFileDialog1.FilterIndex = 2;

saveFileDialog1.RestoreDirectory = true;

if (saveFileDialog1.ShowDialog() == DialogResult.OK) // если файл для записи выбран успешно

{

StreamWriter sw = File.CreateText(saveFileDialog1.FileName); // создаем файл для записи

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

sw.WriteLine(Convert.ToString(xcells)); // ячеек по горизонтали

sw.WriteLine(Convert.ToString(ycells)); // ячеек по вертикали

sw.WriteLine(Convert.ToString(xstart)); // координаты стартовой позиции

sw.WriteLine(Convert.ToString(ystart)); // координаты стартовой позиции

sw.WriteLine(Convert.ToString(xstop)); // координаты конечной позиции

sw.WriteLine(Convert.ToString(ystop)); // координаты конечной позиции

// записываем состояние каждой ячейки

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

{

for (int j = 0; j < ycells; j++)

{

sw.WriteLine(Convert.ToString(lab[i, j, 0]));

ts += lab[i, j, 0];

}

}

sw.WriteLine(Convert.ToString((xcells + ycells + xstart + ystart + xstop + ystop) + ts)); // контрольная сумма

sw.Close(); // закрываем файл

}

}

// Чтение лабиринта из файла

public Boolean Open()

{

OpenFileDialog openFileDialog1 = new OpenFileDialog(); // создаем системный диалог выбора файла

// задаем ему необходимые параметры (свойства)

openFileDialog1.Filter = "Labyrint files (*.lab)|*.lab";

openFileDialog1.FilterIndex = 2;

openFileDialog1.RestoreDirectory = true;

if (openFileDialog1.ShowDialog() == DialogResult.OK) // если файл выбран успешно

{

int cs = 0;

int ts = 0;

try

{

StreamReader sr = File.OpenText(openFileDialog1.FileName); // открываем файл для чтения

// читаем основную информацию о лабиринте

xcells = Convert.ToInt32(sr.ReadLine());

ycells = Convert.ToInt32(sr.ReadLine());

xstart = Convert.ToInt32(sr.ReadLine());

ystart = Convert.ToInt32(sr.ReadLine());

xstop = Convert.ToInt32(sr.ReadLine());

ystop = Convert.ToInt32(sr.ReadLine());

// читаем состояние каждой ячейки

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

{

for (int j = 0; j < ycells; j++)

{

lab[i, j, 0] = Convert.ToInt32(sr.ReadLine());

ts += lab[i, j, 0];

}

}

cs = Convert.ToInt32(sr.ReadLine());

sr.Close(); // закрываем файл

}

catch (Exception e)

{

MessageBox.Show("Ошибка чтения лабиринта. Выберите другой файл.");

return false;

}

// контроль целостности

if ((xcells == 0) || (ycells == 0) || (xstart == 0) || (ystart == 0) || (xstop == 0) || (ystop == 0))

{

MessageBox.Show("Ошибка контроля целостности лабиринта. Выберите другой файл.");

return false;

}

cs = cs - (xcells + ycells + xstart + ystart + xstop + ystop)-ts;

if(cs!=0)

{

MessageBox.Show("Ошибка контроля целостности лабиринта. Выберите другой файл.");

return false;

}

}

return true;

}

}

}

Размещено на Allbest.ru