Проверка столкновений с играми, когда прямоугольник перемещается из одного положения в другое, если он пропустил столкновение в пройденном расстоянии

Question

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

В крайнем случае. [x = 2, x = 1, width = 1, height = 1] A переходит к [x = 4, y = 1, width = 1, height = 1]. Если прямоугольник B существует в [3,1,0,5,0,5], он будет пропущен.

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

public boolean testIntersection(GameVector lowerLeftMain, float mainWidth, float   mainHeight, GameVector lowerLeftCollider, 
float colliderWidth, float colliderHeight){ 

    boolean intersect = false; 

    if(lowerLeftMain.x < lowerLeftCollider.x + colliderWidth+0.08f && //checks left collision 
      lowerLeftMain.x + mainWidth > lowerLeftCollider.x-0.08f && //checks right collision 
      lowerLeftMain.y < lowerLeftCollider.y + colliderHeight+0.08f &&//checks top collision 
      lowerLeftMain.y + mainHeight > lowerLeftCollider.y-0.08f)//checks bottom collision 
     intersect = true; 
    return intersect; 
} 

Возможно, кто-то укажет меня в правильном направлении, должен ли я отказаться от прямоугольников и сконцентрироваться на стиле столкновения лучей?

Заранее спасибо.

Answer 1

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

Моя теорема о раздельной оси в java. Только для проверки наложения. Я пошел на этот алгоритм из-за эффективности и потенциала для просмотра векторов минимума и максимума перекрытия.

public GameVector[] getVertices(GameObject obj){ 
    final GameVector topLeft = new GameVector(obj.mPosition.x-0.06f - (obj.mWidth/2), obj.mPosition.y+0.06f +(obj.mHeight/2)); 
    final GameVector topRight = new GameVector( obj.mPosition.x+0.06f + (obj.mWidth/2),obj.mPosition.y+0.06f +(obj.mHeight/2)); 
    final GameVector bottomLeft = new GameVector( obj.mPosition.x-0.06f - (obj.mWidth/2), obj.mPosition.y-0.06f -(obj.mHeight/2)); 
    final GameVector bottomRight = new GameVector( obj.mPosition.x+0.06f + (obj.mWidth/2), obj.mPosition.y-0.06f -(obj.mHeight/2)); 

    //order here matters 
    GameVector[] vertices = { topLeft, topRight, bottomRight, bottomLeft }; 
    return vertices; 
} 

public GameVector[] getAxis(GameObject shape){ 

    GameVector[] vertices = getVertices(shape); 

    GameVector[] axes = new GameVector[vertices.length]; 
    // loop over the vertices 
    for (int i = 0; i < vertices.length; i++) { 
     // get the current vertex 
     GameVector p1 = vertices[i]; 
     // get the next vertex if i+1 == vertices length set back to vertices [0] 
     GameVector p2 = vertices[i + 1 == vertices.length ? 0 : i + 1]; 
     // subtract the two to get the edge vector 
     GameVector edge = p1.subtract(p2.x, p2.y); 
     // get either perpendicular vector 
     GameVector normal; 
     //get the left side normal of the vector due to clock wise positions 
     normal = new GameVector(edge.y, -edge.x);//edge.perp(); 
     axes[i] = normal; 
    } 
    return axes; 
} 

public float dotProduct(GameVector a, GameVector b){ 
    float dp = a.x*b.x + a.y*b.y; 
    return dp; 
} 

public class Projection { 

    private final float min; 
    private final float max; 

    public Projection(float min, float max) { 
     this.min = min; 
     this.max = max; 
    } 

    public boolean doesOverlap(final Projection other) { 
     return !(this.min > other.max || other.min > this.max); 

    } 
}