AABB 충돌 해결에 문제가 있습니다.

X 축을 먼저 확인한 다음 Y 축을 해결하여 AABB 교차를 해결합니다. 이것은이 버그를 방지하기 위해 수행됩니다 : http://i.stack.imgur.com/NLg4j.png

현재 방법은 객체가 플레이어로 이동하고 플레이어를 가로로 밀어야 할 때 잘 작동합니다. .gif에서 볼 수 있듯이 수평 스파이크는 플레이어를 올바르게 밀어냅니다.

그러나 수직 스파이크가 플레이어로 이동할 때 X 축이 여전히 먼저 해결됩니다. 이것은 "스파이크를 리프트로 사용"을 불가능하게합니다.

플레이어가 수직 스파이크로 이동할 때 (중력의 영향을 받아 그 안에 빠짐) X 축에서 겹치지 않기 때문에 Y 축을 눌렀습니다.

내가 시도한 것은이 링크의 첫 번째 답변에 설명 된 방법입니다 : 2D 직사각형 객체 충돌 감지

그러나 스파이크와 움직이는 객체는 속도가 아닌 위치를 변경하여 이동하며 Update () 메서드가 호출 될 때까지 다음 예측 위치를 계산하지 않습니다. 말할 필요도없이이 솔루션은 효과가 없었습니다. :(

위에서 설명한 두 가지 경우가 의도 한대로 작동하도록 AABB 충돌을 해결해야합니다.

이것은 현재 충돌 소스 코드입니다 : http://pastebin.com/MiCi3nA1

이 버그가 처음부터 엔진에 존재했기 때문에 누군가가 이것을 볼 수 있다면 정말 감사 할 것입니다. 나는 성공하지 않고 좋은 해결책을 찾기 위해 고심하고 있습니다. 이것은 심각하게 충돌 코드를 보면서 밤을 보내고 "재미있는 부분"에 도달하고 게임 로직을 코딩하지 못하게합니다.

XNA AppHub 플랫 포머 데모에서와 동일한 충돌 시스템을 구현하려고 시도했습니다 (대부분의 내용을 복사하여 붙여 넣음). 그러나 "점프"버그는 게임에서 발생하지만 AppHub 데모에서는 발생하지 않습니다. [점프 버그 : http://i.stack.imgur.com/NLg4j.png ]

점프하려면 플레이어가 "onGround"인지 확인한 다음 Velocity.Y에 -5를 추가하십시오.

플레이어의 Velocity.X가 Velocity.Y보다 높으므로 (그림의 네 번째 패널 참조) onGround는 사용하지 않아야 할 경우 true로 설정되어 공중에서 점프 할 수 있습니다.

플레이어의 Velocity.X가 Velocity.Y보다 높지 않기 때문에 AppHub 데모에서는 이러한 현상이 발생하지 않는다고 생각하지만 오해 할 수 있습니다.

X 축을 먼저 해결 한 다음 Y 축을 해결하여이 문제를 해결했습니다. 그러나 위에서 언급 한 것처럼 스파이크와의 충돌을 막습니다.

XNA AppHub 플랫 포머 데모 에 "점프"버그가없는 이유를 알아 냈습니다 . 데모는 충돌 타일을 위에서 아래로 테스트합니다 . "벽"에 도달하면 플레이어가 여러 타일과 겹칠 수 있습니다. 한 충돌을 해결하면 다른 충돌도 해결할 수 있기 때문에 해결 순서가 중요합니다 (그러나 다른 방향으로). 이 onGround속성은 플레이어를 y 축에서 위로 밀어 충돌이 해결 된 경우에만 설정됩니다. 이전 해상도가 플레이어를 아래로 및 / 또는 가로로 밀면이 해상도가 발생하지 않습니다.

이 줄을 변경하여 XNA 데모에서 "점프"버그를 재현 할 수있었습니다.

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

이에:

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

(또한 물리 관련 상수 중 일부를 조정했지만 이것은 중요하지 않습니다.)

bodiesToCheck게임 충돌을 해결하기 전에 y 축을 정렬 하면 "점프"버그가 해결 될 수 있습니다. XNA 데모와 Trevor가 제안한 것처럼 "얕은"침투 축에서 충돌을 해결하는 것이 좋습니다 . 또한 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를 반환합니다.

이동하려면 오른쪽으로 말하고 플레이어 위치를 잡고 x에 4를 더한 다음 위치가 유효한지 확인하십시오. 유효하지 않은 경우 +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) 사이의 전체 공간을 확인해야합니다. 유효한 위치가 없으면 '파쇄'되었음을 의미합니다.

HTH

발 몬드

이 질문에 대답하기 전에 몇 가지 질문이 있습니다. 첫째, 벽에 붙어있는 원래 버그에서 왼쪽 개별 타일의 타일이 하나의 큰 타일과 반대입니까? 그리고 만약 그렇다면 플레이어가 그들 사이에 갇히게 되었습니까? 두 가지 질문에 모두 맞다면, 새로운 직책이 유효한지 확인하십시오 . 즉, 플레이어에게 이동을 지시하는 위치에 충돌이 있는지 확인해야합니다. 아래에 설명 된대로 따라서 최소 변위를 해결하고 그 기반으로 플레이어를 이동에만 그 경우 수저기로 움직여. 코 아래에서도 거의 : 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

문제는 3 단계가 아닌 2 단계입니다.

물건을 견고하게 느끼려고한다면, 아이템이 서로 미끄러 져 들어 가지 않도록해야합니다. 교차로에 있으면 자리를 잃으면 문제를 해결하기가 더 어려워집니다.

스파이크는 플레이어의 존재를 이상적으로 확인해야하며 움직일 때 필요에 따라 그를 밀어야 합니다.

플레이어가 가지고 이것을 달성하는 쉬운 방법입니다 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

물론 플레이어는 여전히 경우 스파이크에 반응 할 필요가 그가 로가는 그들 .

가장 중요한 규칙은 객체가 이동 한 후 교차하지 않는 위치에서 끝나야한다는 것입니다. 이런 식으로, 당신이보고있는 결함을 얻는 것은 불가능합니다.