Мяч к мячу столкновения-обнаружение и обработка

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

• если скорость шарика слишком высоко, вы можете пропустить столкновение.

а также, почти в 100% случаев ваши новые скорости будут неправильными. Ну, не скорость, а позиции. Вы должны рассчитать новые скорости точно в правильном месте. В противном случае вы просто сдвиг шары на некотором небольшом" ошибочном " количестве, которое доступно с предыдущего дискретного шага.

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

вы должны использовать разделение пространства для решения этой проблемы.

Читать далее Двоичного Разбиения и Quadtrees

в качестве пояснения к предложению Райана Фокса разделить экран на регионы и проверять только столкновения внутри регионов...

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

Это абсолютно правильное решение. Единственная проблема с ним (как указал другой плакат) заключается в том, что столкновения через границы являются проблема.

решение этой проблемы заключается в наложении второй сетки на 0,5 единицы вертикального и горизонтального смещения к первому.

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

хороший способ уменьшить количество проверок столкновений-разделить экран на разные секции. Затем вы сравниваете только каждый шар с шарами в том же разделе.

одна вещь, которую я вижу здесь, чтобы оптимизировать.

хотя я согласен, что шары попали, когда расстояние является суммой их радиусов, никогда не следует на самом деле вычислять это расстояние! Скорее, вычислите его квадрат и работайте с ним таким образом. Нет никакой причины для этой дорогостоящей операции с квадратным корнем.

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

Что касается O (n^2), все, что вы можете сделать, это минимизировать стоимость отклонения тех, которые пропускают:

1) мяч, который не движется не может попасть что угодно. Если есть разумное количество шаров, лежащих на полу, это может сэкономить много тестов. (Обратите внимание, что вы все равно должны проверить, если что-то ударило неподвижный шар.)

2) что-то, что может быть стоит сделать: разделите экран на несколько зон, но линии должны быть нечеткими-шары на краю зоны перечислены как находящиеся во всех соответствующих (может быть 4) зонах. Я бы использовал сетку 4x4, храните зоны как биты. Если и из зон двух шаров зон возвращает ноль, конец теста.

3) Как я уже упоминал, не делайте квадратный корень.

Я нашел отличную страницу с информацией об обнаружении столкновений и реакции в 2D.

http://www.metanetsoftware.com/technique.html

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

Edit: обновили ссылку

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

более простой способ-использовать прямоугольную ограничительную рамку, установить размер вашей коробки на 80% от размера шара, и вы будете имитировать столкновение довольно хорошо.

добавить метод в класс мяча:

public Rectangle getBoundingRect()
{
   int ballHeight = (int)Ball.Height * 0.80f;
   int ballWidth = (int)Ball.Width * 0.80f;
   int x = Ball.X - ballWidth / 2;
   int y = Ball.Y - ballHeight / 2;

   return new Rectangle(x,y,ballHeight,ballWidth);
}

затем в цикле:

// Checks every ball against every other ball. 
// For best results, split it into quadrants like Ryan suggested. 
// I didn't do that for simplicity here.
for (int i = 0; i < balls.count; i++)
{
    Rectangle r1 = balls[i].getBoundingRect();

    for (int k = 0; k < balls.count; k++)
    {

        if (balls[i] != balls[k])
        {
            Rectangle r2 = balls[k].getBoundingRect();

            if (r1.Intersects(r2))
            {
                 // balls[i] collided with balls[k]
            }
        }
    }
}

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

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

Да, это два теста, но это будет быстрее в целом.

этой KineticModel реализация привел подход в Java.

я реализовал этот код в JavaScript, используя элемент HTML Canvas, и он произвел замечательные симуляции со скоростью 60 кадров в секунду. Я начал моделирование с набора дюжины шаров в случайных положениях и скоростях. Я обнаружил, что при более высоких скоростях скользящее столкновение между маленьким шаром и гораздо большим шаром заставило маленький шар казаться STICK к краю более большого шарика, и двинуло до около 90 градусов вокруг более большого шарика раньше отделяющий. (Интересно, наблюдал ли кто-нибудь еще такое поведение.)

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

dot_velocity = ball_1.velocity.dot(ball_2.velocity);
mtd_factor = 1. + 0.5 * Math.abs(dot_velocity * Math.sin(collision_angle));
mtd.multplyScalar(mtd_factor);

Я проверил, что до и после этого исправления общая кинетическая энергия была сохранена за каждое столкновение. Значение 0.5 в mtd_factor было приблизительно минимальным значением, которое всегда вызывало разделение шаров после столкновения.

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

Как я вижу здесь, лучший способ его реализации не упоминается. Я отсылаю вас к "как имитировать бильярд и подобные системы" Бориса Д. Любачевского, доступного на arxiv:http://arxiv.org/abs/cond-mat/0503627 в прилагаемом изображении есть скриншот программы, которую я намерен сделать открытым исходным кодом, когда я закончу его. Даже на ранней стадии работает с 5000 сфер довольно гладко. Надеюсь, будет еще лучше, хотя я не хочу реализуйте секторирование, я хочу, чтобы код был легко понятен. Описание будет доступно на http://compphys.go.ro

позднее редактирование: код теперь доступен на GitHub:https://github.com/aromanro/EventMolecularDynamics Описание есть в блоге:http://compphys.go.ro/event-driven-molecular-dynamics/