java - solido - Detección de colisiones con muchos objetos.
no atravesar objetos en unity (3)
Me centré principalmente en los aspectos gráficos para crear un pequeño juego 2D. He visto / visto varios tutoriales, pero ninguno de ellos fue tan agradable. Ya tengo un jugador (un cuadrado) moviéndose y chocando con otros cuadrados en la pantalla. La gravedad, etc. también se hacen.
Si solo hay tantos objetos como se ven en la pantalla (30 * 20), todo funciona perfectamente bien. Pero si lo aumente a digamos 300 * 300, el programa comienza a ejecutarse muy lento, ya que tiene que revisar tantos objetos.
Realmente no entiendo cómo los juegos como Minecraft pueden funcionar con TODOS LOS Bloques y mi programa ya abandona 300 * 300 bloques.
Ya intenté SOLO verificar las colisiones cuando los objetos están visibles, pero eso hace que el programa verifique cada objeto por si su visibilidad conduce al mismo problema. ¿Qué estoy haciendo mal? Ayuda apreciada.
Publicaré un código sobre cómo manejo las colisiones.
player.collision(player, wall);
public void collision(Tile object1, Tile[] object2){
collisionCheckUp(object1, object2);
collisionCheckDown(object1, object2);
collisionCheckLeft(object1, object2);
collisionCheckRight(object1, object2);
}
public void collisionCheckDown(Tile object1, Tile[] object2){
for (int i = 0; i < Map.tileAmount; i++){
if(object2[i] != null && object2[i].visible)
{
if(object1.isCollidingDown(object2[i])){
object1.collisionDown = true;
return;
}
}
}
object1.collisionDown = false;
}
public void compileHullDown(){
collisionHull = new Rectangle((int)x+3, (int)y+3, width-6, height);
}
int wallCount = 0;
for (int x=0;x<Map.WIDTH;x++) {
for (int y=0;y<Map.HEIGHT;y++) {
if (Map.data[x][y] == Map.BLOCKED) {
wall[wallCount] = new Tile(x * Map.TILE_SIZE, y * Map.TILE_SIZE);
wallCount++;
}
}
}
El enfoque habitual para optimizar la detección de colisiones es utilizar una partición espacial para clasificar / administrar sus objetos.
La idea general del enfoque es que usted construye un árbol que representa el espacio y coloca sus objetos en ese árbol, de acuerdo con sus posiciones. Cuando calculas las colisiones, atraviesas el árbol. De esta manera, tendrá que realizar significativamente menos cálculos que utilizando el enfoque de fuerza bruta, ya que ignorará todos los objetos en las ramas que no sea la que está atravesando. Minecraft y similares probablemente usan octrees para colisiones (y quizás también para renderizar).
Las estructuras de partición de espacio más comunes son BSP-Trees , kd-Trees (un tipo especial de BSP-trees). El enfoque más simple sería usar una partición de espacio uniforme para el inicio: divida su espacio en mitades alineadas con el eje.
El mejor recurso de colisión que he descubierto es este libro . Debe aclarar todas sus preguntas sobre el tema.
Eso es si querías hacerlo bien. Si quieres hacerlo rápido, puedes simplemente muestrear el búfer de color alrededor de tu personaje, o solo en la dirección del movimiento para determinar si un obstáculo está cerca.
Puede reducir su sobrecarga en un factor de 4, en lugar de calcular las colisiones para arriba / abajo / izquierda / derecha, calculando las colisiones una vez y utilizando las posiciones relativas de los dos objetos para averiguar si golpea un piso, pared o techo . Otra buena idea es prestar solo atención a los objetos que están cerca. ¿Es posible que una vez cada 0.25 segundos haga una lista de todos los objetos que probablemente estén lo suficientemente cerca para colisionar en los siguientes 0.25 segundos?