413 lines
16 KiB
C#
413 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using nkast.Aether.Physics2D.Common;
|
|
using tainicom.Aether.Physics2D.Fluids;
|
|
using CtrEditor.Simulacion.Fluids.Components;
|
|
|
|
namespace CtrEditor.Simulacion.Fluids.Components
|
|
{
|
|
/// <summary>
|
|
/// Clase base para todos los componentes de fluidos
|
|
/// </summary>
|
|
public abstract class ComponenteFluido : IContenedorFluido
|
|
{
|
|
public Vector2 Posicion { get; set; }
|
|
public bool EsActivo { get; set; } = true;
|
|
|
|
/// <summary>
|
|
/// Convierte una posición de metros/WPF a sistema de coordenadas de FluidSystem2
|
|
/// </summary>
|
|
protected Vector2 ConvertirPosicion(Vector2 posicion, int worldWidth)
|
|
{
|
|
return new Vector2(
|
|
posicion.X * 100 - worldWidth/2,
|
|
posicion.Y * 100
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Implementación en clases derivadas para restricciones específicas
|
|
/// </summary>
|
|
public abstract void RestringirParticula(Particle particula);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tanque para contener fluidos
|
|
/// </summary>
|
|
public class Tanque : ComponenteFluido
|
|
{
|
|
public float Ancho { get; set; }
|
|
public float Alto { get; set; }
|
|
private int _worldWidth;
|
|
|
|
// Coordenadas ajustadas al sistema de FluidSystem2
|
|
private float _xMin, _xMax, _yMin, _yMax;
|
|
private float _coefRebote = 0.3f; // Factor de rebote en colisiones
|
|
|
|
/// <summary>
|
|
/// Constructor para un tanque
|
|
/// </summary>
|
|
/// <param name="posicion">Posición del centro del tanque</param>
|
|
/// <param name="ancho">Ancho del tanque</param>
|
|
/// <param name="alto">Alto del tanque</param>
|
|
/// <param name="worldWidth">Ancho del mundo en cm (para conversión de coordenadas)</param>
|
|
public Tanque(Vector2 posicion, float ancho, float alto, int worldWidth)
|
|
{
|
|
Posicion = posicion;
|
|
Ancho = ancho;
|
|
Alto = alto;
|
|
_worldWidth = worldWidth;
|
|
|
|
ActualizarLimites();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Actualiza los límites internos del tanque después de cambiar la posición o tamaño
|
|
/// </summary>
|
|
public void ActualizarLimites()
|
|
{
|
|
// Convertir a coordenadas internas
|
|
_xMin = (Posicion.X - Ancho/2) * 100 - _worldWidth/2;
|
|
_xMax = (Posicion.X + Ancho/2) * 100 - _worldWidth/2;
|
|
_yMin = Posicion.Y * 100;
|
|
_yMax = (Posicion.Y + Alto) * 100;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restringe las partículas para que permanezcan dentro del tanque
|
|
/// </summary>
|
|
public override void RestringirParticula(Particle particula)
|
|
{
|
|
if (!EsActivo) return;
|
|
|
|
// Comprobar si la partícula está dentro del área del tanque
|
|
bool dentroX = particula.Position.X >= _xMin && particula.Position.X <= _xMax;
|
|
bool dentroY = particula.Position.Y >= _yMin && particula.Position.Y <= _yMax;
|
|
|
|
if (dentroX && dentroY)
|
|
{
|
|
// La partícula está dentro del tanque, comprobar si está cerca de los bordes
|
|
if (particula.Position.X < _xMin + 5)
|
|
{
|
|
particula.Position.X = _xMin + 5;
|
|
particula.Velocity.X *= -_coefRebote;
|
|
}
|
|
else if (particula.Position.X > _xMax - 5)
|
|
{
|
|
particula.Position.X = _xMax - 5;
|
|
particula.Velocity.X *= -_coefRebote;
|
|
}
|
|
|
|
if (particula.Position.Y < _yMin + 5)
|
|
{
|
|
particula.Position.Y = _yMin + 5;
|
|
particula.Velocity.Y *= -_coefRebote;
|
|
}
|
|
else if (particula.Position.Y > _yMax - 5)
|
|
{
|
|
particula.Position.Y = _yMax - 5;
|
|
particula.Velocity.Y *= -_coefRebote;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtiene el nivel de llenado del tanque en porcentaje
|
|
/// </summary>
|
|
/// <param name="simulacion">Instancia activa de la simulación</param>
|
|
/// <returns>Porcentaje de llenado (0-1)</returns>
|
|
public float ObtenerNivelLlenado()
|
|
{
|
|
// Sería necesario acceder a las partículas para calcular esto
|
|
// Implementación en clases derivadas específicas
|
|
return 0.0f;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Representa un segmento de tubo para fluidos
|
|
/// </summary>
|
|
public class SegmentoTubo
|
|
{
|
|
public Vector2 Inicio { get; }
|
|
public Vector2 Fin { get; }
|
|
public float Radio { get; }
|
|
|
|
public SegmentoTubo(Vector2 inicio, Vector2 fin, float radio)
|
|
{
|
|
Inicio = inicio;
|
|
Fin = fin;
|
|
Radio = radio;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Contiene y restringe el movimiento de una partícula dentro del tubo
|
|
/// </summary>
|
|
/// <returns>Verdadero si se aplicó alguna restricción</returns>
|
|
public bool ContenerParticula(Particle particula)
|
|
{
|
|
// Calcular distancia de la partícula al segmento de línea
|
|
Vector2 pos = new Vector2(particula.Position.X, particula.Position.Y);
|
|
float distancia = DistanciaPuntoALinea(pos, Inicio, Fin);
|
|
|
|
// Si la distancia es mayor que el radio, aplicar restricción
|
|
if (distancia > Radio)
|
|
{
|
|
// Calcular punto más cercano en el segmento
|
|
Vector2 puntoMasCercano = PuntoMasCercanoEnLinea(pos, Inicio, Fin);
|
|
|
|
// Dirección desde partícula hacia punto más cercano en el centro del tubo
|
|
Vector2 direccion = VectorUtils.NormalizeVector(puntoMasCercano - pos);
|
|
|
|
// Mover la partícula al interior del tubo
|
|
particula.Position.X = puntoMasCercano.X - direccion.X * Radio * 0.9f;
|
|
particula.Position.Y = puntoMasCercano.Y - direccion.Y * Radio * 0.9f;
|
|
|
|
// Ajustar velocidad para simular rebote
|
|
float velocidadNormal = VectorUtils.DotProduct(
|
|
new Vector2(particula.Velocity.X, particula.Velocity.Y),
|
|
direccion);
|
|
|
|
particula.Velocity.X -= direccion.X * velocidadNormal * 1.8f;
|
|
particula.Velocity.Y -= direccion.Y * velocidadNormal * 1.8f;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false; // La partícula está dentro del tubo
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcula la distancia de un punto a una línea
|
|
/// </summary>
|
|
private float DistanciaPuntoALinea(Vector2 punto, Vector2 lineaInicio, Vector2 lineaFin)
|
|
{
|
|
// Vector que representa la dirección de la línea
|
|
Vector2 linea = lineaFin - lineaInicio;
|
|
float longitud = linea.Length();
|
|
|
|
if (longitud < 0.0001f)
|
|
return VectorUtils.DistanceBetween(punto, lineaInicio); // Es un punto, no una línea
|
|
|
|
// Normalizar el vector de la línea
|
|
Vector2 lineaNormalizada = linea / longitud;
|
|
|
|
// Vector desde el inicio de la línea hasta el punto
|
|
Vector2 puntoDesdeInicio = punto - lineaInicio;
|
|
|
|
// Proyectar puntoDesdeInicio sobre la línea
|
|
float proyeccion = VectorUtils.DotProduct(puntoDesdeInicio, lineaNormalizada);
|
|
|
|
// Limitar la proyección al segmento de línea
|
|
proyeccion = Math.Max(0, Math.Min(longitud, proyeccion));
|
|
|
|
// Punto más cercano en la línea
|
|
Vector2 puntoMasCercano = lineaInicio + lineaNormalizada * proyeccion;
|
|
|
|
// Distancia desde el punto hasta el punto más cercano
|
|
return VectorUtils.DistanceBetween(punto, puntoMasCercano);
|
|
}
|
|
|
|
/// Calcula el punto más cercano en una línea desde un punto dado
|
|
/// </summary>
|
|
private Vector2 PuntoMasCercanoEnLinea(Vector2 punto, Vector2 lineaInicio, Vector2 lineaFin)
|
|
{
|
|
// Vector que representa la dirección de la línea
|
|
Vector2 linea = lineaFin - lineaInicio;
|
|
float longitud = linea.Length();
|
|
|
|
if (longitud < 0.0001f)
|
|
return lineaInicio; // Es un punto, no una línea
|
|
|
|
// Normalizar el vector de la línea
|
|
Vector2 lineaNormalizada = linea / longitud;
|
|
|
|
// Vector desde el inicio de la línea hasta el punto
|
|
Vector2 puntoDesdeInicio = punto - lineaInicio;
|
|
|
|
// Proyectar puntoDesdeInicio sobre la línea
|
|
float proyeccion;
|
|
Vector2.Dot(ref puntoDesdeInicio, ref lineaNormalizada, out proyeccion);
|
|
|
|
// Limitar la proyección al segmento de línea
|
|
proyeccion = Math.Max(0, Math.Min(longitud, proyeccion));
|
|
|
|
// Punto más cercano en la línea
|
|
return lineaInicio + lineaNormalizada * proyeccion;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tubería para conducir fluidos entre puntos
|
|
/// </summary>
|
|
public class Tuberia : ComponenteFluido
|
|
{
|
|
private List<SegmentoTubo> _segmentos = new List<SegmentoTubo>();
|
|
private List<Vector2> _puntos = new List<Vector2>();
|
|
public float Diametro { get; private set; }
|
|
private int _worldWidth;
|
|
|
|
/// <summary>
|
|
/// Constructor para una tubería
|
|
/// </summary>
|
|
/// <param name="diametro">Diámetro de la tubería</param>
|
|
/// <param name="worldWidth">Ancho del mundo en cm (para conversión de coordenadas)</param>
|
|
public Tuberia(float diametro, int worldWidth)
|
|
{
|
|
Diametro = diametro;
|
|
_worldWidth = worldWidth;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Agrega un punto a la tubería, creando segmentos automáticamente
|
|
/// </summary>
|
|
public void AgregarPunto(Vector2 punto)
|
|
{
|
|
// Convertir punto a coordenadas internas
|
|
Vector2 puntoAjustado = ConvertirPosicion(punto, _worldWidth);
|
|
|
|
// Si ya hay puntos, crear un segmento con el punto anterior
|
|
if (_puntos.Count > 0)
|
|
{
|
|
_segmentos.Add(new SegmentoTubo(
|
|
_puntos[_puntos.Count - 1],
|
|
puntoAjustado,
|
|
Diametro * 100 / 2 // Radio en unidades internas
|
|
));
|
|
}
|
|
|
|
_puntos.Add(puntoAjustado);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restringe las partículas para que permanezcan dentro de la tubería
|
|
/// </summary>
|
|
public override void RestringirParticula(Particle particula)
|
|
{
|
|
if (!EsActivo) return;
|
|
|
|
// Comprobar si la partícula está cerca de la tubería
|
|
Vector2 posParticula = new Vector2(particula.Position.X, particula.Position.Y);
|
|
float distanciaMinima = float.MaxValue;
|
|
SegmentoTubo segmentoMasCercano = null;
|
|
|
|
// Encontrar el segmento más cercano
|
|
foreach (var segmento in _segmentos)
|
|
{
|
|
float distancia = DistanciaPuntoASegmento(posParticula, segmento.Inicio, segmento.Fin);
|
|
if (distancia < distanciaMinima)
|
|
{
|
|
distanciaMinima = distancia;
|
|
segmentoMasCercano = segmento;
|
|
}
|
|
}
|
|
|
|
// Aplicar restricciones si hay un segmento cercano
|
|
if (segmentoMasCercano != null)
|
|
{
|
|
segmentoMasCercano.ContenerParticula(particula);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcula la distancia desde un punto a un segmento de línea
|
|
/// </summary>
|
|
private float DistanciaPuntoASegmento(Vector2 punto, Vector2 segmentoInicio, Vector2 segmentoFin)
|
|
{
|
|
// Vector dirección del segmento
|
|
Vector2 segmento = segmentoFin - segmentoInicio;
|
|
float longitudCuadrada = segmento.LengthSquared();
|
|
|
|
if (longitudCuadrada < 0.0001f)
|
|
return VectorUtils.DistanceBetween(punto, segmentoInicio); // Es un punto, no un segmento
|
|
|
|
// Calcular proyección del punto sobre el segmento
|
|
float t = VectorUtils.DotProduct(punto - segmentoInicio, segmento) / longitudCuadrada;
|
|
t = Math.Max(0, Math.Min(1, t));
|
|
|
|
// Punto más cercano en el segmento
|
|
Vector2 proyeccion = segmentoInicio + t * segmento;
|
|
|
|
// Distancia desde el punto hasta la proyección
|
|
return VectorUtils.DistanceBetween(punto, proyeccion);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Válvula para controlar el flujo de fluidos
|
|
/// </summary>
|
|
public class Valvula : ComponenteFluido
|
|
{
|
|
public float Apertura { get; set; } // 0.0 = cerrada, 1.0 = abierta
|
|
public float Diametro { get; set; }
|
|
private int _worldWidth;
|
|
private Vector2 _posicionAjustada;
|
|
|
|
/// <summary>
|
|
/// Constructor para una válvula
|
|
/// </summary>
|
|
/// <param name="posicion">Posición de la válvula</param>
|
|
/// <param name="diametro">Diámetro del conducto de la válvula</param>
|
|
/// <param name="apertura">Apertura inicial (0-1)</param>
|
|
/// <param name="worldWidth">Ancho del mundo en cm (para conversión de coordenadas)</param>
|
|
public Valvula(Vector2 posicion, float diametro, float apertura, int worldWidth)
|
|
{
|
|
Posicion = posicion;
|
|
Diametro = diametro;
|
|
Apertura = Math.Clamp(apertura, 0, 1);
|
|
_worldWidth = worldWidth;
|
|
|
|
_posicionAjustada = ConvertirPosicion(posicion, worldWidth);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Actualiza la posición ajustada después de cambiar la posición
|
|
/// </summary>
|
|
public void ActualizarPosicion(Vector2 nuevaPosicion)
|
|
{
|
|
Posicion = nuevaPosicion;
|
|
_posicionAjustada = ConvertirPosicion(nuevaPosicion, _worldWidth);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restringe y modula el flujo de partículas a través de la válvula
|
|
/// </summary>
|
|
public override void RestringirParticula(Particle particula)
|
|
{
|
|
if (!EsActivo) return;
|
|
|
|
// Calcular distancia al centro de la válvula
|
|
Vector2 posParticula = new Vector2(particula.Position.X, particula.Position.Y);
|
|
float distancia = VectorUtils.DistanceBetween(_posicionAjustada, posParticula);
|
|
float radioValvula = Diametro * 100 / 2; // Radio en unidades internas
|
|
|
|
// Verificar si la partícula está dentro del radio de acción de la válvula
|
|
if (distancia < radioValvula * 1.2)
|
|
{
|
|
// Si la válvula está cerrada o casi cerrada, bloquear paso
|
|
if (Apertura < 0.05f)
|
|
{
|
|
// Rechazar partícula
|
|
Vector2 direccion = VectorUtils.NormalizeVector(posParticula - _posicionAjustada);
|
|
particula.Position.X = _posicionAjustada.X + direccion.X * (radioValvula * 1.2f);
|
|
particula.Position.Y = _posicionAjustada.Y + direccion.Y * (radioValvula * 1.2f);
|
|
|
|
// Reducir velocidad significativamente
|
|
particula.Velocity.X *= 0.1f;
|
|
particula.Velocity.Y *= 0.1f;
|
|
}
|
|
// Si está parcialmente abierta, reducir velocidad proporcionalmente
|
|
else if (Apertura < 0.9f)
|
|
{
|
|
// Calcular factor de reducción basado en la apertura
|
|
float factorReduccion = Apertura * Apertura; // Relación no lineal
|
|
|
|
// Aplicar resistencia proporcional a la apertura
|
|
particula.Velocity.X *= factorReduccion;
|
|
particula.Velocity.Y *= factorReduccion;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|