/// <summary>
/// Computa el area donde se proyecta el rayo.
/// </summary>
/// <returns></returns>
private Rectangle ComputeRayArea()
{
Vector2 a = this.Source;
Vector2 b = MathTools.Move(this.Source, this.Radius, Math.Abs(this.Direction)); this.Hit = b;
if (a.X > b.X)
{
Helper.Swap <float>(ref a.X, ref b.X);
}
if (a.Y > b.Y)
{
Helper.Swap <float>(ref a.Y, ref b.Y);
}
/* En caso de que la direccion sea perpendicular, para evitar que el area de interseccion sea plana (sin volumen)
* segun la direccion incrementamos o decrementamos en 1 la altura o anchura del area: */
switch ((int)this.Direction)
{
case 0:
case 180: a.Y--; b.Y++; break;
case 90:
case 270: a.X--; b.X++; break;
}
return(new Rectangle((int)a.X, (int)a.Y, (int)(b.X - a.X), (int)(b.Y - a.Y)));
}
/// <summary>
/// Dibuja la representacion grafica del cuerpo.
/// </summary>
public void Draw()
{
// Si se definio el metodo de pre dibujado lo ejecutamos:
if (this.PreDraw != null)
{
PreDraw(this);
}
// Dibujamos el area del cuerpo:
Helper.DrawBox(Rectangle, Color);
// Escribimos el angulo:
if (Debug)
{
string directions = (Left ? "Left\n" : "") + (Up ? "Up\n" : "") + (Right ? "Right\n" : "") + (Down ? "Down" : "");
if (!Fixed)
{
Helper.DrawText(Direction.ToString() + "º\n" + directions, new Vector2(Rectangle.X + 1, Rectangle.Y + 1), Color.White);
}
}
// Si no es un cuerpo fijo y este se ha movido en la ultima iteracion dibujamos una linea que represente la direccion:
if (!Fixed && Direction > -1)
{
// Obtenemos el extremo de la linea desplazando las coordenadas xy 32 pixeles en la direccion recorrida:
Vector2 endPoint = MathTools.Move(Center, 32, Direction);
// Dibujamos la linea:
Helper.DrawLine(Center, endPoint, Color.Blue);
}
// Si se definio el metodo de post dibujado lo ejecutamos:
if (this.PostDraw != null)
{
PostDraw(this);
}
}
/// <summary>
/// Actualiza el estado de la escena.
/// </summary>
public void Update()
{
// Actualizamos los estados de todos los cuerpos de la escena que no sean fijos y esten activos:
foreach (Body body in bodies)
{
// Si se definio, ejecutamos el metodo de pre actualizacion del cuerpo:
if (body.PreUpdate != null) body.PreUpdate(body);
body.Update();
}
// Recorremos la lista de cuerpos de la escena y calculamos sus colisiones y su respuesta en caso de haber colision:
foreach (Body currentBody in bodies)
{
// Buscamos colisiones con el resto de cuerpos de la escena:
collisions.Clear();
foreach (Body body in bodies)
{
// Descartamos al cuerpo actual en la busqueda:
if (currentBody != body && currentBody.Enabled)
if (currentBody.Rectangle.Intersects(body.Rectangle))
collisions.Add(body);
}
// Evaluamos la respuesta a la colision:
if (collisions.Count > 0)
{
// Si hay colisiones con el cuerpo actual lanzamos el evento y enviamos la lista de cuerpos que colisionan:
if (currentBody.OnCollision != null)
currentBody.OnCollision(collisions.ToArray());
// Descartamos primero cualquier cuerpo que no sea solido para no calcular respuesta con el:
List<Body> collisionsToResponse = new List<Body>();
foreach (Body body in collisions)
if (body.Solid && body.Fixed) collisionsToResponse.Add(body);
if (collisionsToResponse.Count > 0)
{
// Invertimos el angulo de direccion que tenia el cuerpo:
float dir = currentBody.Direction + (currentBody.Direction > 180 ? -180 : 180);
// Si hay colisiones obtenemos la respuesta a la colision para recolocar el cuerpo:
int count; do
{
// Retrocediendo un pixel en la direccion opuesta que recorria el cuerpo:
currentBody.Location = MathTools.Move(currentBody.Location, 1, dir);
// Comprobamos las colisiones restantes:
count = collisionsToResponse.Count;
foreach (Body b in collisionsToResponse)
if (!currentBody.Rectangle.Intersects(b.Rectangle)) count--;
}
while (count > 0);
// Igualamos la ultima posicion con la actual de la correccion para anular la direccion tomada en el proximo Update() del cuerpo:
currentBody.lastPoint = currentBody.Location;
}
}
}
// Si se definio, ejecutamos el metodo de post actualizacion del cuerpo:
foreach (Body body in bodies)
if (body.PostUpdate != null) body.PostUpdate(body);
}
