Javascript phsyics en un espacio 2d

Question

Por lo tanto, estoy trabajando en la enseñanza de Canvas (HTML5) y tengo la mayoría del motor de un juego simple codificado. Es una representación 2D de una escena espacial (planetas, estrellas, cuerpos celestes, etc.). Mi clase "Sprite" predeterminada tiene un detector de marcos como el siguiente:

"baseClass" contiene una función que permite la herencia y aplica "a" a "this.a". Entonces, "var aTest = new Sprite ({foo: 'bar'});" haría "aTest.foo = 'bar'". Así es como expongo mis objetos el uno al otro.

Sprite = baseClass.extend({ 
    init: function(a){ 
    baseClass.init(this, a); 
    this.fields = new Array(); // list of fields of gravity one is in. Not sure if this is a good idea. 
    this.addFL(function(tick){ // this will change to be independent of framerate soon. 

     // gobjs is an array of all the Sprite objects in the "world". 
     for(i = 0; i < gobjs.length; i++){ 

     // Make sure its got setup correctly, make sure it -wants- gravity, and make sure it's not -this- sprite. 
     if(typeof(gobjs[i].a) != undefined && !gobjs[i].a.ignoreGravity && gobjs[i].id != this.id){ 
      // Check if it's within a certain range (obviously, gravity doesn't work this way... But I plan on having a large "space" area, 
      // And I can't very well have all objects accounted for at all times, can I? 
      if(this.distanceTo(gobjs[i]) < this.a.size*10 && gobjs[i].fields.indexOf(this.id) == -1){ 
      gobjs[i].fields.push(this.id); 
      } 
     } 
     } 
     for(i = 0; i < this.fields.length; i++){ 
     distance = this.distanceTo(gobjs[this.fields[i]]); 

     angletosun = this.angleTo(gobjs[this.fields[i]])*(180/Math.PI); // .angleTo works very well, returning the angle in radians, which I convert to degrees here. 

     // I have no idea what should happen here, although through trial and error (and attempting to read Maths papers on gravity (eeeeek!)), this sort of mimics gravity. 
     // angle is its orientation, currently I assign a constant velocity to one of my objects, and leave the other static (it ignores gravity, but still emits it). 
     // This cant be right, because it just _sets_ the angle regardless of whatever it was. 
     // This is where we need to find "the average of the forces". 
     this.a.angle = angletosun+(75+(distance*-1)/5); //todo: omg learn math 

     if(this.distanceTo(gobjs[this.fields[i]]) > gobjs[this.fields[i]].a.size*10){ 
      this.fields.splice(i); // out of range, stop effecting. 
     } 
     } 
    }); 

    //draw objects based on new position (from fixed velocity and angle). 

    } 
}); 

Gracias de antemano. El verdadero truco es esa línea, y por cierto sé que no tiene ningún sentido. Grados + distancia = falla.

this.a.angle = angletosun+(75+(distance*-1)/5); 

Esto es más una cuestión de física de Javascript, pero he buscado y buscado y leído manera a muchos artículos wiki sobre matemáticas orbitales. Se me pasa por la cabeza muy rápidamente.

Answer 1

Oh, esto me lleva por el carril de la memoria, jugar con la simulación física es muy divertido.

En cualquier caso, parece que necesita pulir sus matemáticas vectoriales, eso es probablemente el tema más importante, este artículo debe contener todo lo que necesita saber sobre matemáticas vectoriales, aunque no estoy seguro si es la fuente más fácil disponible. http://en.wikipedia.org/wiki/Euclidean_vector

Su código parece estar un poco orientado al objeto, por supuesto que es una cuestión de preferencia, pero me quedaría con objetos de datos puros y mantendría la lógica en funciones separadas.

Y aquí hay un poco de matemáticas físicas para comenzar, cada objeto debe tener una posición como un vector, una velocidad como un vector y una masa.

Para cada pulso que hace dos cosas, para cada objeto se agrega la velocidad a la posición:

p=p+v 

Y por cada objeto con respecto a todos los demás objetos se cambia la velocidad de acuerdo con la fuerza de gravedad calculado . la velocidad de B cambiaría al igual que a causa de la gravedad de un bien:

B.v=B.v+(A.p-B.p)*(A.m/(|A.p-B.p|^3)) 

Una vez que haya agrietado matemáticas vectoriales que debe ser capaz de traducir esto en código real.