Mercury13

Перед нами совершенно необъектный код, на вид тупо написанный на Си средствами Си++. Так что будет несложно.
1. Убрать из структуры private/public.
2. Вынести функции из структуры, явно прописав в них this:

int BMP::Load(char FileNames[])
→
int BMPLoad(struct BMP* this, char FileNames[])

3. Для старых версий Си — поднять определения всех переменных на верх функции.

А что нам с масштабированием? — на вид написан на том же Си и ничего не требует, кроме задания этого this.

Ну разумеется, по критерию параллелограмма: диагонали пересекаются и точкой пересечения делятся пополам! На языке математики:
x1 + x3 ≈ x2 + x4
y1 + y3 ≈ y2 + y4
Почему «приблизительно равно». Float в принципе неточный, совпадение приходится проверять с точностью в какой-то эпсилон. Какой эпсилон — это уже зависит от задачи.

Это обыкновенный IBM (разве что, возможно, с несколько кастрированным BIOS’ом), там нормальная, без RT, Windows.
Я могу дома погонять, правда, у меня самый обычный настольник с вебкой. А так…
doc.qt.io/qt-5/cameraoverview.html
https://habrahabr.ru/post/148775/
На вид их API ещё в виде беты… ну, я на работе и не могу пока разобрать.

Мультисписок имеет несколько указателей «next» и позволяет собирать несколько (до N) не связанных друг с другом списков по разным признакам, не дублируя полезной нагрузки.

typedef enum {
  LI_A, LI_B, LI_N
} ListIndex;

enum { LEN = 40 };

typedef struct {
  Entry* next[LI_N];
  char name[LEN];
} Entry;

typedef Entry* PEntry;
PEntry heads[LI_N], tails[LI_N];    // считаем, что = NULL

int isIn(ListIndex aIndex, Entry* aEntry)
{
  return (aEntry->next[aIndex] || tails[aIndex] == aEntry);
}

void addExisting(ListIndex aIndex, Entry* aEntry)
{
   /* Уже есть? Поскольку такой код чреват ошибками, лучше всё же проверить */
  if (isIn(aIndex, aEntry))
    return;
  if (tails[aIndex]) {
    tails[aIndex]->next = aEntry;
    tails[aIndex] = aEntry;
  } else {
    heads[aIndex] = tails[aIndex] = aEntry;
  }
}

Entry* addNew(ListIndex aIndex, char* aName)
{
  int i;
  Entry* newEntry = (Entry*)malloc(sizeof(Entry));
  strncpy(entry->name, aName, LEN);
  entry->name[LEN-1] = '\0';
  for (i = 0; i < LI_N, ++i)
    entry->next[i] = NULL;
  addExisting(aIndex, entry);
  return entry;
}

/* closure — т.н. замыкание, передача контекста, из которого была
   вызвана функция, вызывающая callback */
typedef void(*ListCallback)(Entry* aEntry, void* aClosure);

void traverseList(ListIndex aIndex, ListCallback aCallback, void* aClosure)
{
  Entry* entry = heads[aIndex];
  while (entry) {
    aCallback(aEntry, aClosure);
    entry = entry->next[aIndex];
  }
}

О замыкании можно прочитать тут: Для чего нужны замыкания в C++ и как вы их используете?

Допустим, надо перезаписать i-й полёт.
Надо перескочить на i*sizeof(…), и там читать-писать. То есть

if (strcmp(flight_d[i].destination, edit) == 0)
            {
                   flight_d[i] = …;
                   file.open(…);
                   file.seekg(i * sizeof(…));
                   file.write(reinterpret_cast<const char*>(&flight_d[i]),
                                         sizeof(Flight_Details));
                   break;
            }

Да, и вы путаете глобальную переменную flight_d и локальную flight.

double* min(double **Arr, int SizeArr) {
   // Всё оставь как есть, убери вывод   
   return MinArr;
}

Ну и не забудь уничтожить результат функции min где-то ниже по коду. «Си с крестами» сам ничего созданного через new не уничтожит.

Рассказываю на пальцах.
Компьютер запомнил число (или кучу чисел), которое называется «случайная затравка» (random seed).
По команде «сгенерируй случайное число» он проводит два алгоритма.

1. Собственно генератор случайных чисел — преобразование seed → seed.
Например: seed := (37·seed + 234) mod 997.
(знаком :=, как в Паскале, я обозначил «переприсвоить»)

2. Интерпретация результатов: seed → Y*.
Например, y = seed/997.
Y — это [0…1), {1…6} или любое другое желаемое множество.
Y* — множество конечных последовательностей: каждый бросок генератора может не дать ни одного числа (и потребуется переброс), одно число, два числа… Например, наиболее известный генератор нормально распределённых чисел каждым броском даёт или ноль чисел (т.е. нужен переброс), или сразу два.

Затравку надо инициализировать чем-то действительно случайным, и для этого используют таймер, счётчик тактов и прочие труднопредсказуемые места. А ещё можно запомнить затравку и снова повторить ту же последовательность чисел (раньше это использовали для повторов и мультиплеера в играх).

Если же нужны настоящие случайные числа, да в большом количестве — это откровенно тяжело. В ход идут…
• таймеры и счётчики команд — ну, это понятно;
• шум в звуковой плате;
• задержки ввода с клавиатуры и мыши;
• аппаратные датчики случайных чисел на диодном шуме, применяемые в некоторых процессорах.
MacOS, например, этим добром не пользуется; и в dev/random, и в dev/urandom идёт один и тот же криптостойкий псевдослучайных генератор Ярроу.

1. У вас неверное условие (z[i].birth >= ageyoungest).
2. Никакой защиты от переполнения буфера в scanf.
3. Идентификатор birth реально означает возраст. Плохо.
4. Неверное условие

if (z[i].education == "master" || z[i].education == "specialist" || z[i].education == "bachelor")

. Для массивов это просто сравнение адреса массива с адресом вкомпилированной в программу строчки, что автоматически даёт false. Используйте str(n)cmp.
5. Излишнее условие

else if (z[i].education != "master" || z[i].education != "specialist" || z[i].education != "bachelor")

. Оно автоматически выполнено.
6. Отсутствует delete[] employees;

Информационная безопасность требует от вас понимать, что такое эксплойт. Потому нужны оба языка. Может, не очень глубоко, но какой-то код надо писать на том и на другом.
Дело в том, что «няшная сишка» стала отличным полигоном для эксплойтов, да и низкоуровневые библиотеки пишут часто на ней (для компактности). А на Си++ пишут современный софт.
Раз вы на ПэХаПэ, вы не понимаете, что такое указатель, и потому лучше начать с Си++. Просто потому, что как-то можно программировать без указателей, а понять, что это за чёрт указатель — дело наживное.

1. Виртуальный деструктор тут нужен — ведь в списке будут вперемешку элементы разных классов.
2. Не видны два компонента, которые и делают список связным — указатель на следующий элемент (test* next) и указатель на голову (test* head = NULL).
3. В попытке скрыть реальную жизненную задачу — ведь СС не вещь в себе, а решает какую-то задачу вроде «держать список объектов в игре» — вы слишком уж напереименовывались.

В первую очередь авиасимуляторы. Знаю, что из-за масштабов Земли им приходится справляться с ошибками float: если Земля 12000 км в поперечнике, то единица младшего разряда — полметра.
Первый X-COM имел круглую землю, но полёты были по локсодроме. А вот в опенсорсном ремейке 2014 года полёты уже по большому кругу.
Симуляторы бога от Питера Молиньё: Populous, Black and White. Возможно, и другие симуляторы богов (например, Spore — не проверял).

Я говорю именно про шарообразную карту, а не трубу/тор.

А так — я бы предостерёг от шарообразной земли с открытым миром. 1) Расстояния (глобальная карта с ускоренным временем или без времени не в счёт). 2) Навигация по миру (в том числе понятие «север»), проекция миникарты. 3) В какой-то момент нужно закругляться и выкатывать игру, а в какой-то — выдавать аддон. Тяжеловато будет. Кстати, во всех упомянутых играх мир или замкнутый, или намного больше, чем одна планета.

P.S. Моё определение открытого мира: игра, дающая относительную свободу действий и передвижения, но локальный участок, где орудует игрок/группа, намного меньше мира. В замкнутом мире, наоборот, участник орудует практически по всему «миру», оперативно переходя с одного участка на другой. Есть и пограничные случаи: огромное побережье нового Hitman — открытый мир или замкнутый?