# Colisiones irregulares con hitboxes.

### Pregunta

• Bueno resulto que ando haciendo un juego plataformas y ya he resuelto la fisica y la colision con tiles:

``` public void physics(GameTime time, Global level)
{
if (!TileColission(new Vector2(Position.X, Position.Y + velocity.Y / 3 * level.scale), level,1))
{
Position.Y += velocity.Y  / 3 * level.scale;
standingOnGround = false;
}
else
{
if (TileColission(new Vector2(Position.X, Position.Y + 1 * level.scale), level, 1))
{
standingOnGround = true;
}
velocity.Y = 0;
}
if (direction=="right"&&!TileColission(new Vector2(Position.X + velocity.X * time.ElapsedGameTime.Milliseconds / 3 * level.scale, Position.Y), level,0))
{
Position.X += velocity.X * time.ElapsedGameTime.Milliseconds / 3 * level.scale;
}
else {
if (direction == "right")
{
velocity.X = 0;
}
}
if (direction == "left" && !TileColission(new Vector2(Position.X - velocity.X * time.ElapsedGameTime.Milliseconds / 3 * level.scale, Position.Y), level,0))
{
Position.X -= velocity.X * time.ElapsedGameTime.Milliseconds / 3 * level.scale;
}
else {
if(direction=="left")
{
velocity.X = 0;
}
}

}```

este es el codigo de comprobado de las colisiones y aqui como resuelvo el if de tilecolision:

```   public bool TileColission(Vector2 Position, Global level, int type)
{
foreach (Tile t in level.map.roomTile)
{
if (t.colisiontype == 1)
if (rec(Position, level.scale).Intersects(t.rec(level.scale)))
{

return true;

}
if (t.colisiontype == 3)
if (rec(Position, level.scale).Intersects(t.rec(level.scale)))
{

return true;

}
if (t.colisiontype == 5)
{
if (rec(Position, level.scale).Intersects(t.rec(level.scale)))
{
//aqui slope izquierdo
}
if (t.colisiontype == 7)
{
//aqui slope derecho
}
if (t.colisiontype == 6)
if (type == 1)
{
if (Keyboard.GetState().IsKeyDown(level.Down) && Keyboard.GetState().IsKeyDown(level.Jump))
{
bajando = true;
}
if (!bajando)
{
if (rec(Position, level.scale).Intersects(t.recOneWay(level.scale)))

if (!rec(this.Position, level.scale).Intersects(t.recOneWay(level.scale)))
{
if (velocity.Y > 0)
{
return true;
}

}
}
bajando = false;
}

}
//ahora los de arriba
foreach (Tile t in level.map.roomTileUp)
{

}

return false;

}```

imagenes del mapa de hitbox:

y los hitbox:

*El hitbox azul es el focus de la camara

Como podria resolver las colisiones irregulares de hitboxes?

gracias de antemano.

lunes, 02 de febrero de 2015 9:25

### Todas las respuestas

• Bueno despues de no recibir ninguna respuesta y estar pensandolo mucho he acabado sacando los slopes de 45*

aunque no haya recibido ayuda voy a explicar como lo hice y tal por si alguien se encuentra en el mismo problema y no lo puede solucionar reconozco que es un tema jodido.

Para empezar vamos a necesitar dos cosas:

- Detectar la colision para que cuando caigamos encima de el se detecte como solido y colisionemos justo donde toque es decir si por ejemplo tenemos un slope triangular de 45 de 16 pixelex por 16 la formula que funciona y que es segura es la siguiente la posicion exacta en la que tiene que detectar la colision sera determinada por la siguiente formula(para slope derecho al inverso para izquierdo)

player.y=player.x-tile.x; y con esta simple formula damos con la magia de saber la altura en la que nos deberemos encontrar tras la caida ejemplo:

si me encuentro en la posición 10 y el tile esta en la 0 tenemos que  la y del jugador debe ser 10 con la formula

-Moverse horizontalmente subiendo en la Y si detectamos colision con el suelo o tile en si( ya que si intentamos movernos normalmente este detectara colision y por tanto no se movera xd).

Vale ahora que ya tenemos explicado lo que vamos hacer empezaremos detectando la colision.

Para detectar la colision se me ocurrio la brillante idea de aplicar  lo siguiente.

Si nos encontramos en el caso anterior y la posicion del jugador debe ser 10 y por tanto detectar que estamos tocando suelo en ese momento porque creamos un rectangulo el cual tenga esa altura y si hay colision decimos que estamos en el suelo?

Con este metodo logramos detectar si hay colision con el slope y nos devuelve un bool como un intersect ;)

```	public bool collisionWithSlopeLeftUp(Tile t, Vector2 position, Global global)
{
this.t = t;
Rectangle rec = new Rectangle((int)((int)t.position.X),((int)t.position.Y), 16,-(+(int)t.position.X-((int)Position.X+6)));
if (rec.Intersects(this.rec(position, global.scale)))
{
return true;
}
return false;
}
public bool collisionWithSlopeLeft(Tile t, Vector2 position, Global global)
{
this.t = t;
Rectangle rec = new Rectangle((int)((int)t.position.X),((int)t.position.Y)-(+(int)t.position.X-((int)Position.X+6)), 16,16);
if (rec.Intersects(this.rec(position, global.scale)))
{
return true;
}
return false;
}```

y esto son mis dos metodos nota: esto esta hecho para un rectangulo de colision(jugador) de 6*14 y unos tiles de 16*16.

Bueno ya tenemos solucionado la deteccion de la colision ahora como escalamos el bloque?

Pues con el siguiente codigo podemos hacer esto de una manera muy facil

```    public void positionSlopeY(Global global)
{
foreach (Tile t in global.map.roomTile)
{
if (t.colisiontype == 5) // tipo derecho
{
if (rec(Position, global.scale).Intersects(t.rec(global.scale)))
{
if(is_onground)
Position.Y =(t.position.Y) +((int)t.position.X - ((int)Position.X + 10));
}
}
if (t.colisiontype == 7) // me refiero al tipo izquierdo
{
if (rec(Position, global.scale).Intersects(t.rec(global.scale)))
{
if (is_onground)
Position.Y =(t.position.Y-16) +(-(int)t.position.X+((int)Position.X+6));
}
}
}```

es necesario y importante decir que cuando estamos en un tile slope se ejecute todo esto en vez de las colisiones normales.

Espero a ver ayudado y si no queda claro algo ya lo aclarare.

Un saludo

lunes, 09 de febrero de 2015 8:38