phsyics Javascript in uno spazio 2d

Question

Quindi, sto lavorando per insegnarmi Canvas (HTML5) e ho la maggior parte di un semplice motore di gioco codificato. È una rappresentazione 2D di una scena spaziale (pianeti, stelle, corpi celesti, ecc.). La mia classe "Sprite" predefinita ha un listener di cornici come questo:

"baseClass" contiene una funzione che consente l'ereditarietà e applica "a" a "this.a". Quindi, "var aTest = new Sprite ({foo: 'bar'});" farebbe "aTest.foo = 'bar'". Questo è il modo in cui espongo i miei oggetti l'un l'altro.

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). 

    } 
}); 

Grazie in anticipo. Il vero trucco è una linea, e so che non ha assolutamente senso. Gradi + distanza = fallimento.

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

Questa è più una questione di fisica di JavaScript, ma ho cercato e cercato e leggere modo per molti articoli wiki sulla matematica orbitali. Mi viene in mente la molto velocemente.

Answer 1

Oh, questo mi porta alla memoria, giocare con la simulazione della fisica è molto divertente.

In ogni caso, sembra che tu abbia bisogno di ottenere la tua matematica vettoriale lucidata, che è probabilmente la cosa più importante, questo articolo dovrebbe contenere tutto ciò che devi sapere sulla matematica vettoriale, anche se non sono sicuro che sia è la fonte più semplice disponibile. http://en.wikipedia.org/wiki/Euclidean_vector

Il tuo codice sembra un po 'esageratamente orientato agli oggetti, ovviamente è una questione di preferenza, ma mi limiterei a puri oggetti dati e manterrò la logica in funzioni separate.

E qui c'è un po 'di matematica fisica per iniziare, ogni oggetto deve avere una posizione come vettore, una velocità come vettore e massa.

Per ogni tick che fai due cose, per ogni oggetto si aggiunge la velocità alla posizione:

p=p+v 

E per ogni oggetto rispetto ad ogni altro oggetto si cambia la velocità in base alla forza gravitazionale calcolato . la velocità di B cambierebbe così come la gravità a causa di un pozzo:

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

volta incrinato la matematica vettoriale si dovrebbe essere in grado di tradurre questo in codice vero e proprio.