У меня проблема с разрешением коллизий AABB.

Я разрешаю пересечение AABB, сначала разрешив ось X, а затем ось Y. Это сделано для предотвращения этой ошибки: http://i.stack.imgur.com/NLg4j.png

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

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

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

Что-то, что я попробовал, был метод, описанный в первом ответе этой ссылки: 2D обнаружение столкновения прямоугольного объекта

Однако шипы и движущиеся объекты перемещаются, изменяя их положение, а не скорость, и я не вычисляю их следующую прогнозируемую позицию до тех пор, пока не будет вызван их метод Update (). Излишне говорить, что это решение тоже не сработало. :(

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

Это мой текущий исходный код столкновения: http://pastebin.com/MiCi3nA1

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

Я попытался реализовать ту же систему коллизий, что и в демонстрационной платформе XNA AppHub (скопировав большую часть материала). Однако в моей игре возникает «прыгающая» ошибка, а в демке AppHub ее нет. [прыгающая ошибка: http://i.stack.imgur.com/NLg4j.png ]

Чтобы прыгнуть, я проверяю, находится ли игрок на «OnGround», затем добавляю -5 к Velocity.Y.

Поскольку Velocity.X игрока выше, чем Velocity.Y (см. Четвертую панель на диаграмме), onGround устанавливается в true, когда этого не должно быть, и, таким образом, позволяет игроку прыгать в воздухе.

Я полагаю, что этого не происходит в демоверсии AppHub, потому что Velocity.X игрока никогда не будет выше Velocity.Y, но я могу ошибаться.

Я решил это раньше, решив сначала по оси X, а затем по оси Y. Но это усиливает столкновение с шипами, как я уже говорил выше.

Хорошо, я понял, почему у демоверсии платформера XNA AppHub нет «прыгающей» ошибки: демоверсия тестирует плитки столкновений сверху вниз . Находясь напротив «стены», игрок может перекрывать несколько плиток. Порядок разрешения важен, потому что разрешение одного столкновения может также разрешить другие столкновения (но в другом направлении). onGroundСвойство устанавливается только тогда , когда столкновение решается нажатием игрока на оси у. Это разрешение не произойдет, если предыдущие разрешения толкали игрока вниз и / или по горизонтали.

Я смог воспроизвести «прыгающую» ошибку в демоверсии XNA, изменив эту строку:

for (int y = topTile; y <= bottomTile; ++y)

к этому:

for (int y = bottomTile; y >= topTile; --y)

(Я также подправил некоторые физические константы, но это не должно иметь значения.)

Возможно, сортировка bodiesToCheckпо оси Y перед разрешением коллизий в вашей игре исправит ошибку «прыжка». Я предлагаю разрешить столкновение на «мелкой» оси проникновения, как это делает демонстрация XNA и Тревор . Также обратите внимание, что демонстрационный проигрыватель XNA в два раза больше плиток, способных к столкновению, что повышает вероятность множественного столкновения.

Самым простым решением для вас будет проверить оба направления столкновения для каждого объекта в мире, прежде чем разрешать любые столкновения, и просто разрешить меньшее из двух возникающих «составных столкновений». Это означает, что вы решаете наименьшее возможное значение, вместо того, чтобы всегда разрешать x первым или всегда разрешать y первым.

Ваш код будет выглядеть примерно так:

// This loop repeats, until our object has been fully pushed outside of all
// collision objects
while ( StillCollidingWithSomething(object) )
{
  float xDistanceToResolve = XDistanceToMoveToResolveCollisions( object );
  float yDistanceToResolve = YDistanceToMoveToResolveCollisions( object );
  bool xIsColliding = (xDistanceToResolve != 0.f);

  // if we aren't colliding on x (not possible for normal solid collision 
  // shapes, but can happen for unidirectional collision objects, such as 
  // platforms which can be jumped up through, but support the player from 
  // above), or if a correction along y would simply require a smaller move 
  // than one along x, then resolve our collision by moving along y.

  if ( !xIsColliding || fabs( yDistanceToResolve ) < fabs( xDistanceToResolve ) )
  {
    object->Move( 0.f, yDistanceToResolve );
  }
  else // otherwise, resolve the collision by moving along x
  {
    object->Move( xDistanceToResolve, 0.f );
  }
}

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

bool StillCollidingWithSomething( MovingObject object )
{
  // loop over every collision object in the world.  (Implementation detail:
  // don't test 'object' against itself!)
  for( int i = 0; i < collisionObjectCount; i++ )
  {
    // if the moving object overlaps any collision object in the world, then
    // it's colliding
    if ( Overlaps( collisionObject[i], object ) )
      return true;
  }
  return false;
}

float XDistanceToMoveToResolveCollisions( MovingObject object )
{
  // check how far we'd have to move left or right to stop colliding with anything
  // return whichever move is smaller
  float moveOutLeft = FindDistanceToEmptySpaceAlongNegativeX(object->GetPosition());
  float moveOutRight = FindDistanceToEmptySpaceAlongX(object->GetPosition());
  float bestMoveOut = min( fabs(moveOutLeft), fabs(moveOutRight) );

  return minimumMove;
}

float FindDistanceToEmptySpaceAlongX( Vector2D position )
{
  Vector2D cursor = position;
  bool colliding = true;
  // until we stop colliding...
  while ( colliding )
  {
    colliding = false;
    // loop over all collision objects...
    for( int i = 0; i < collisionObjectCount; i++ )
    {
      // and if we hit an object...
      if ( Overlaps( collisionObject[i], cursor ) )
      {
        // move outside of the object, and repeat.
        cursor.x = collisionObject[i].rightSide;
        colliding = true;

        // break back to the 'while' loop, to re-test collisions with
        // our new cursor position
        break;
      }
    }
  }
  // return how far we had to move, to reach empty space
  return cursor.x - position.x;  
}

Это не тест "для каждой пары объектов"; он не работает, тестируя и сопоставляя движущийся объект с каждой плиткой карты мира в отдельности (этот подход никогда не будет работать надежно, и он будет приводить к катастрофическим последствиям при уменьшении размеров плитки). Вместо этого он тестирует движущийся объект против каждого объекта на карте мира одновременно, а затем разрешается на основе столкновений с картой всего мира.

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

редактировать

Я улучшил это

Кажется, ключевая вещь, которую я изменил, - это классификация пересечений.

Пересечения либо:

• Потолочные неровности
• Наземные удары (толчок из пола)
• Столкновения в воздухе
• Столкновения с заземленной стеной

и я решаю их в таком порядке

Определите столкновение с землей как игрок, находящийся как минимум на 1/4 пути на тайле

Так что это столкновение с землей, и игрок ( синий ) будет сидеть на вершине плитки ( черный )

Но это НЕ наземное столкновение, и игрок «соскользнет» с правой стороны плитки, когда он приземлится на нее.

При таком способе игрок больше не будет попадаться по бокам стен

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

Мое решение:

Когда я столкнулся с такими проблемами в моем 2d-платформере, я сделал что-то вроде следующего:

- (движок быстро обнаруживает возможные столкновения)
- (игра информирует движок о точных столкновениях для конкретного объекта) [возвращает вектор объекта *]
- (объект смотрит на глубину проникновения, а также на предыдущую позицию относительно предыдущей позиции другого объекта, определить, с какой стороны выскользнуть)
- (объект движется и усредняет свою скорость со скоростью объекта (если объект движется))

В видеоиграх, которые я запрограммировал, подход заключался в том, чтобы иметь функцию, сообщающую, является ли ваша позиция действительной, т.е. bool ValidPos (int x, int y, int wi, int he);

Функция проверяет ограничивающий прямоугольник (x, y, wi, he) на всю геометрию в игре и возвращает false, если есть пересечение.

Если вы хотите переместиться, скажем, вправо, занять позицию игрока, добавить 4 к x и проверить, является ли позиция действительной, если нет, проверять с помощью + 3, + 2 и т. Д., Пока она не будет.

Если вам также нужна гравитация, вам нужна переменная, которая растет до тех пор, пока вы не коснетесь земли (удар по земле: ValidPos (x, y + 1, wi, he) == true, y здесь положительно вниз). если вы можете переместиться на это расстояние (т. е. ValidPos (x, y + gravity, wi, he) возвращает true), вы падаете, иногда полезно, когда вы не сможете контролировать своего персонажа при падении.

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

Если это не так, вам нужно найти позицию, которая есть. Если игровые объекты не могут двигаться быстрее, чем, скажем, 2 пикселя за игровой оборот, вам нужно проверить, является ли позиция (x, y-1) действительной, затем (x, y-2), затем (x + 1, y) и т. Д. и т. д. следует проверять все пространство между (x-2, y-2) - (x + 2, y + 2). Если нет действительной позиции, значит, вы были «раздавлены».

НТН

Valmond

У меня есть несколько вопросов, прежде чем я начну отвечать на это. Во-первых, в первоначальной ошибке, в которой вы застряли в стенах, были ли эти плитки на левой отдельной плитке в отличие от одной большой плитки? И если они были, игрок застрял между ними? Если да на оба этих вопроса, просто убедитесь, что ваша новая позиция действительна . Это означает, что вам нужно проверить, нет ли столкновения с тем, куда вы указываете игроку двигаться. Так что решите минимальное смещение, как описано ниже, и затем двигайте своего игрока, основываясь на этом, только если он можетиди туда. Почти тоже под носом: P Это на самом деле представит еще одну ошибку, которую я называю «угловыми случаями». По существу, с точки зрения углов (например, в левом нижнем углу, где горизонтальные шипы появляются в вашем .gif, но если бы не было шипов), это не разрешило бы столкновение, потому что казалось бы, что ни одно из созданных вами разрешений не приведет к правильной позиции , Чтобы решить эту проблему, просто укажите, было ли разрешено столкновение, а также список всех минимальных разрешений проникновения. После этого, если столкновение не было разрешено, выполните циклическое повторение каждого созданного вами разрешения и отслеживайте максимальное X и максимальное разрешение Y (максимальные значения не должны приходиться на одно и то же разрешение). Затем разрешите столкновение на этих максимумах. Кажется, это решит все ваши проблемы, а также те, с которыми я столкнулся.

    List<Vector2> collisions = new List<Vector2>();
        bool resolved = false;
        foreach (Platform p in testPlat)
        {
            Vector2 dif = p.resolveCollision(player.getCollisionMask());

            RectangleF newPos = player.getCollisionMask();

            newPos.X -= dif.X;
            newPos.Y -= dif.Y;


            if (!PlatformCollision(newPos)) //This checks if there's a collision (ie if we're entering an invalid space)
            {
                if (dif.X != 0)
                    player.velocity.X = 0; //Do whatever you want here, I like to stop my player on collisions
                if (dif.Y != 0)
                    player.velocity.Y = 0;

                player.MoveY(-dif.Y);
                player.MoveX(-dif.X);
                resolved = true;
            }
            collisions.Add(dif);
        }

        if (!resolved)
        {
            Vector2 max = Vector2.Zero;

            foreach (Vector2 v in collisions)
            {
                if (Math.Abs(v.X) > Math.Abs(max.X))
                {
                    max.X = v.X;
                }
                if (Math.Abs(v.Y) > Math.Abs(max.Y))
                {
                    max.Y = v.Y;
                }
            }

            player.MoveY(-max.Y);

            if (max.Y != 0)
                player.velocity.Y = 0;
            player.MoveX(-max.X);

            if (max.X != 0)
                player.velocity.X = 0;
        }

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

Хорошо, так что в основном это то, что описывал @Trevor Powell. Поскольку вы используете только AABB, все, что вам нужно сделать, - это найти, насколько один прямоугольник проникает в другой. Это даст вам количество по осям X и Y. Выберите минимум из двух, и переместите ваш сталкивающийся объект вдоль этой оси на это количество. Это все, что вам нужно для разрешения коллизии AABB. При таком столкновении вам НИКОГДА не нужно будет перемещаться по нескольким осям, поэтому вас никогда не должно смущать вопрос о том, какой из них двигаться первым, поскольку вы будете двигаться только по минимуму.

Метанет программное обеспечение имеет классический учебник по подходу здесь . Это также входит в другие формы также.

Вот функция XNA, которую я сделал, чтобы найти вектор перекрытия двух прямоугольников:

    public Point resolveCollision(Rectangle otherRect)
    {
        if (!isCollision(otherRect))
        {
            return Point.Zero;
        }

        int minOtherX = otherRect.X;
        int maxOtherX = otherRect.X + otherRect.Width;

        int minMyX = collisionMask.X;
        int maxMyX = collisionMask.X + collisionMask.Width;

        int minOtherY = otherRect.Y;
        int maxOtherY = otherRect.Y + otherRect.Height;

        int minMyY = collisionMask.Y;
        int maxMyY = collisionMask.Y + collisionMask.Height;

        int dx, dy;

        if (maxOtherX - minMyX < maxMyX - minOtherX)
        {
            dx = (maxOtherX - minMyX);
        }
        else
        {
            dx = -(maxMyX - minOtherX);
        }

        if (maxOtherY - minMyY < maxMyY - minOtherY)
        {
            dy = (maxOtherY - minMyY);
        }
        else
        {
            dy = -(maxMyY - minOtherY);
        }

        if (Math.Abs(dx) < Math.Abs(dy))
            return new Point(dx, 0);
        else
            return new Point(0, dy);
    }

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

isCollision (Rectangle) буквально является просто вызовом XNA Rectangle.Intersects (Rectangle).

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

Это просто.

Перепишите шипы. Это вина шипов.

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

1. Player is outside spikes
2. Spikes move into intersection position with the player
3. Player resolves incorrectly

Проблема с шагом 2, а не 3 !!

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

Шипы в идеале должны проверять наличие игрока, а когда они двигаются, они должны толкать его по мере необходимости.

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

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

function spikes going up:

    move spikes up

    if intersecting player:
        d = player bottom edge + spikes top edge

        player.moveY(-d)
    end if

end function

Очевидно, что игрок все равно должен реагировать на шипы, если он в них попадает .

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