# Примеры конфигураций карт

## Простая карта (обучение)

```csharp
int width = 15;
int height = 15;
var start = new Point(1, 1);

var checkpoints = new Dictionary<int, Point>
{
    { 1, new Point(5, 5) },
    { 2, new Point(10, 10) }
};

var obstacles = new HashSet<Point>();
// Простая стена
for (int x = 3; x <= 8; x++)
    obstacles.Add(new Point(x, 7));
```

**Ожидаемое время:**
- BFS: < 1 сек
- A*: < 0.5 сек

---

## Средняя сложность (лабиринт)

```csharp
int width = 25;
int height = 25;
var start = new Point(2, 2);

var checkpoints = new Dictionary<int, Point>
{
    { 1, new Point(8, 8) },
    { 2, new Point(20, 20) },
    { 3, new Point(22, 5) }
};

var obstacles = new HashSet<Point>();

// Горизонтальные стены
for (int x = 5; x <= 15; x++)
{
    obstacles.Add(new Point(x, 10));
    obstacles.Add(new Point(x + 5, 15));
}

// Вертикальные стены
for (int y = 5; y <= 15; y++)
{
    obstacles.Add(new Point(12, y));
    obstacles.Add(new Point(18, y));
}

// Блок препятствий
for (int x = 8; x <= 10; x++)
    for (int y = 3; y <= 5; y++)
        obstacles.Add(new Point(x, y));
```

**Ожидаемое время:**
- BFS: 5-15 сек
- A*: 1-3 сек

---

## Высокая сложность (большая карта)

```csharp
int width = 42;
int height = 42;
var start = new Point(2, 2);

var checkpoints = new Dictionary<int, Point>
{
    { 1, new Point(10, 10) },
    { 2, new Point(30, 35) },
    { 3, new Point(38, 8) },
    { 4, new Point(15, 30) },
    { 5, new Point(25, 15) }
};

var obstacles = new HashSet<Point>();

// Спиральный лабиринт
for (int x = 5; x <= 35; x++)
    obstacles.Add(new Point(x, 15));

for (int y = 5; y <= 35; y++)
    obstacles.Add(new Point(20, y));

for (int x = 10; x <= 30; x++)
    obstacles.Add(new Point(x, 25));

// Диагональные стены
for (int i = 0; i <= 15; i++)
{
    obstacles.Add(new Point(25 + i, 25 + i));
    obstacles.Add(new Point(10 + i, 5 + i));
}

// Комнаты
CreateRoom(obstacles, 35, 18, 3, 3);
CreateRoom(obstacles, 8, 32, 4, 4);

void CreateRoom(HashSet<Point> obs, int startX, int startY, int w, int h)
{
    for (int x = startX; x < startX + w; x++)
        for (int y = startY; y < startY + h; y++)
            obs.Add(new Point(x, y));
}
```

**Ожидаемое время:**
- BFS: >30 сек (или не найдет)
- A*: 1-5 сек

---

## Экстремальная сложность (гоночная трасса)

```csharp
int width = 60;
int height = 60;
var start = new Point(3, 3);

var checkpoints = new Dictionary<int, Point>
{
    { 1, new Point(15, 10) },
    { 2, new Point(45, 15) },
    { 3, new Point(50, 45) },
    { 4, new Point(25, 50) },
    { 5, new Point(10, 35) },
    { 6, new Point(30, 30) }
};

var obstacles = new HashSet<Point>();

// Внешняя граница трассы
for (int i = 5; i <= 55; i++)
{
    obstacles.Add(new Point(i, 5));
    obstacles.Add(new Point(i, 55));
    obstacles.Add(new Point(5, i));
    obstacles.Add(new Point(55, i));
}

// Внутренние препятствия - создаем узкие проходы
for (int y = 10; y <= 50; y += 10)
{
    for (int x = 10; x <= 45; x++)
    {
        if (x % 15 < 3) // Оставляем проходы
            obstacles.Add(new Point(x, y));
    }
}

// S-образные повороты
for (int i = 0; i <= 20; i++)
{
    obstacles.Add(new Point(20 + i, 20 + i / 2));
    obstacles.Add(new Point(40 - i, 30 + i / 2));
}
```

**Ожидаемое время:**
- BFS: Может не найти решение
- A*: 5-20 сек

---

## Тестирование физики (ускорение)

```csharp
// Длинная прямая дорога - тестирует высокие скорости
int width = 80;
int height = 20;
var start = new Point(2, 10);

var checkpoints = new Dictionary<int, Point>
{
    { 1, new Point(75, 10) }
};

var obstacles = new HashSet<Point>();

// Граничные стены
for (int x = 0; x < width; x++)
{
    obstacles.Add(new Point(x, 0));
    obstacles.Add(new Point(x, 19));
}
```

**Ожидаемый результат:**
- Машина должна разогнаться до максимальной скорости
- Оптимальное решение: ~10-12 ходов

---

## Челлендж: Узкие проходы

```csharp
int width = 30;
int height = 30;
var start = new Point(2, 2);

var checkpoints = new Dictionary<int, Point>
{
    { 1, new Point(15, 15) },
    { 2, new Point(27, 27) }
};

var obstacles = new HashSet<Point>();

// Создаем зигзагообразный узкий коридор
for (int y = 5; y <= 25; y++)
{
    int offset = (y / 5) % 2 == 0 ? 0 : 10;
    for (int x = 8 + offset; x <= 20 + offset; x++)
    {
        if (x < 10 + offset || x > 18 + offset)
            obstacles.Add(new Point(x, y));
    }
}
```

**Челлендж:**
- Требует точного управления скоростью
- Нельзя разгоняться слишком сильно
- Тестирует алгоритм торможения

---

## Как использовать

1. Скопируйте нужную конфигурацию
2. Замените код в `Main` метод в `Program.cs` или `ProgramAStar.cs`
3. Запустите программу
4. Сравните время работы BFS и A*

## Генератор случайных карт

```csharp
public static HashSet<Point> GenerateRandomObstacles(int width, int height, int density)
{
    var random = new Random();
    var obstacles = new HashSet<Point>();
    
    int totalCells = width * height;
    int obstacleCount = totalCells * density / 100;
    
    while (obstacles.Count < obstacleCount)
    {
        int x = random.Next(width);
        int y = random.Next(height);
        obstacles.Add(new Point(x, y));
    }
    
    return obstacles;
}

// Использование:
var obstacles = GenerateRandomObstacles(40, 40, 15); // 15% препятствий
```

## Советы по созданию интересных карт

1. **Баланс сложности**: 10-20% препятствий от площади поля
2. **Проходы**: Всегда оставляйте пути между чекпоинтами
3. **Узкие места**: Создают интересные челленджи для алгоритма
4. **Длинные прямые**: Позволяют разгоняться
5. **Зигзаги**: Требуют точного управления скоростью
6. **Комнаты**: Добавляют разнообразие

## Тестирование масштабируемости

```bash
# Маленькая карта (15×15, 2 чекпоинта)
# Ожидается: BFS и A* одинаково быстрые

# Средняя карта (30×30, 3 чекпоинта)
# Ожидается: A* в 2-3 раза быстрее

# Большая карта (50×50, 4 чекпоинта)
# Ожидается: A* в 5-10 раз быстрее

# Огромная карта (80×80, 5+ чекпоинтов)
# Ожидается: BFS не справится, A* найдет решение
```