Что здесь нового в C++

const float g = 9.8f;

Слово const перед типом запрещает менять значение. Попытка написать g = 10.f; где угодно в программе станет ошибкой компиляции.

Зачем запрещать себе то, чего и так не собираешься делать? Затем, что «не собираешься» действует, пока помнишь. В программе на тысячу строк можно случайно завести вторую переменную с тем же именем или присвоить не туда. const превращает такую ошибку из загадочного поведения в сообщение компилятора с номером строки.

Правило простое: если величина не должна меняться – напишите const. Это ничего не стоит.

const float TARGET_X1 = 8.5f,  TARGET_Y1 = 3.0f;
float x, y;

Тип пишется один раз, дальше через запятую идут имена. Строка короче, и связанные величины видны рядом.

Пользоваться этим стоит только для действительно связанных величин – как здесь, где x и y вместе задают одну точку. Список из семи разнородных переменных в одну строку читается плохо.

std::vector<float> ground_x = {-0.1f, 10.f};

Фигурные скобки сразу заполняют вектор перечисленными значениями – не нужно ни задавать размер, ни звать push_back для каждого элемента.

Удобно, когда значений немного и они известны заранее. Когда точек пятьдесят и они считаются по формуле, работает другой способ – цикл с push_back, как в make_target.

float k = (float)i / TARGET_POINTS;

Запись (float)i означает «возьми i и посчитай его вещественным числом». Это приведение типа, и здесь оно спасает от целочисленного деления: без него 17 / 50 дало бы ноль, а не 0.34.

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

В современном C++ у той же операции есть более длинная запись:

float k = static_cast<float>(i) / TARGET_POINTS;

Она делает ровно то же самое. Длиннее – намеренно: приведение типа бывает опасным, и авторы языка хотели, чтобы его было видно издалека. В новом коде принято писать так; короткая форма из старого кода никуда не денется, и знать надо обе.

for (size_t i = 0; i < target_x.size(); i++) {
    ...
    if (distance < HIT_RADIUS)
        return true;
}
return false;

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

Это стандартный приём для вопроса «есть ли среди них хоть один такой». Он экономит время: если попадание нашлось на пятой точке из пятидесяти, сорок пять проверок не выполнятся.

Обратный приём – вопрос «все ли такие»: тогда в цикле стоит return false на первом же несовпадении, а return true – в конце.

if (flying && !pause) { ... }

Значение типа bool уже само по себе условие, сравнивать его не с чем. Писать if (flying == true) не нужно – это то же самое, что if (flying), только длиннее. А вот опечатка if (flying = true) (одно равно вместо двух) – настоящая беда: она не сравнивает, а присваивает, и условие всегда оказывается истинным.

Ещё одна деталь: в a && b вторая часть не вычисляется, если первая уже ложна. Это называется сокращённым вычислением и часто используется как защита: if (i < v.size() && v[i] > 0) не обратится к несуществующему элементу.

Значение nan – это «не число». Оно заразно: любая арифметика с ним снова даёт nan, и через несколько кадров в nan превращается всё состояние задачи. На графике это выглядит как внезапно исчезнувшая линия. Если такое случилось – ищите корень из отрицательного или деление на ноль.

Это не приём, а предупреждение, и в баллистике оно встречается впервые.

if (y <= 0.f) { ... }     // так можно
if (y == 0.f) { ... }     // так почти всегда неправильно

Тип float хранит числа приближённо. Тело, летящее вниз, за один шаг перепрыгивает с $y = 0.03$ на $y = -0.05$, ни разу не побывав ровно в нуле, – и проверка на равенство не сработает никогда.

Поэтому вещественные числа сравнивают с порогом: «меньше», «больше», а если нужно именно равенство – «отличается меньше чем на $\varepsilon$»:

if (fabs(y) < 1e-6f) { ... }