Urto elastico

di Anonimizzato10204 il
17 risposte
Apro questo thread per discutere con chi ne fosse interessato dell' algoritmo per calcolare i rimbalzi tra sfere in movimento.
Questo algoritmo serve per sviluppare un programma che sto facendo in parallelo ad altri utenti dell'area mobile ma che può benissimo essere fatto anche su pc.

17 Risposte

  • Le informazioni sull' urto elastico sono a questo indirizzo
  • Lo avevo già Visto ed è fatto bene, ora vorrei convertirlo in codice.
  • L'' esempio monodimensionale é facile e convertirlo in codice pure. L' esempio sul piano ti é chiaro?
  • In linea di principio si, ma come applicarlo no! Poi nell' animazione si vede una palla in movimento che urta una palla ferma, noi abbiamo due palle in movimento.
  • É già noi abbiamo due palle che girano! Dato che il moto é relativo non ci si potrebe mettere sempre nel sistema di riferimento di una palla, che qundi sarebbe ferma, per semplificare le cose?
  • Faccio fatica a capire se sarebbe più semplice o più complicato!
  • Secondo me se ti metti a fare traslazioni degli assi ti incasini, ti conviene usare le formule direttamente.
  • barba59 ha scritto:


    Secondo me se ti metti a fare traslazioni degli assi ti incasini, ti conviene usare le formule direttamente.
    A me sembra che le formule diventano un casino se consideri le due palle in
    movimento.
  • Bisogna proiettare le componenti del moto sull' asse che congiunge i centri,
    applicare la formula del rimbalzo e comporre i risultati con le componenti
    ortogonali che non cambiamo.
  • Ok, questo in teoria ma come si fa?
  • Boh
  • Orso Bruno ha scritto:


    Boh
    Tanto lo so che lo sai e fai solo lo spiritoso

    Comunque un ripassino di geometria fa sempre bene.

    La posizione di un corpo nel piano è data da due coordinate x, y e possiamo usare una classe Point per indicarla, la velocità di un corpo nel piano è data da un vettore che ha due componenti vx e vy e usiamo una classe Vector per indicarla.

    Mi raccomando fate i bravi e non usate la stessa classe per indicare posizione e velocità, pur essendo entrambe una coppia di numeri, sono due cose diverse!

    Quando devi proiettare una velocità lungo una certa direzione (ad esempio la velocità della sfera lungo la retta che congiunge i centri) si usa il prodotto scalare (da non confondere con il prodotto per uno scalare), il risultato è la componente della velocità lungo quella retta.

    Dato che un esempio vale più di mille parole scrivo due classi Point e Vector che hanno tutti i metodi necessari per risolvere il probleme dei rimbalzi.
    
        public class Point
        {
            public double X { get; set; }
            public double Y { get; set; }
    
            public Point(double x, double y)
            {
                X = x;
                Y = y;
            }
    
            public double Distance(Point p)
            {
                double a = X - p.X;
                double b = Y - p.Y;
                return Math.Sqrt(a * a + b * b);
            }
        }
    
    
        public class Vector
        {
            public double X { get; set; }
            public double Y { get; set; }
    
            public Vector(double x, double y)
            {
                X = x;
                Y = y;
            }
    
            public Vector(Point p1, Point p2)
            {
                X = p2.X - p1.X;
                Y = p2.Y - p1.Y;
            }
    
            public static Vector Add(Vector a, Vector b)
            {
                return new Vector(a.X + b.X, a.Y + b.Y);
            }
    
            public double DotProduct(Vector v)  // Prodotto scalare
            {
                return X * v.X + Y * v.Y;
            }
    
            public double Magnitude   // Norma o lunghezza del vettore
            {
                get { return Math.Sqrt(X * X + Y * Y); }
            }
    
            public Vector Multiply(double d) // moltiplicazione per uno scalare
            {
                return new Vector(X * d, Y * d);
            }
    
            public Vector Normalize
            {
                get { return Multiply(1 / Magnitude); }
            }
    
            public Vector Ortogonal
            {
                get { return new Vector(-Y, X); }
            }
    
            public Vector Project(Vector v)
            {
                Vector vn = v.Normalize;
                return vn.Multiply(DotProduct(vn));
            }
        }
    
    Naturalmente nel NetFramework esistono già delle classi simili.
  • Non mi è chiaro il metodo Hortogonal.
  • Insieme facciamo una bella coppia, io dimentico le h e tu le metti fuori posto! Si scrive Orthogonal

    A parte le h, il metodo Orthogonal serve per trovare un vettore ortogonale a quallo dato, ho sottolineato un perchè ne esistono due, per il nostro problema ce ne basta uno qualsiasi.
Devi accedere o registrarti per scrivere nel forum
17 risposte