Modelagem de órbita elíptica

Estou brincando com órbitas em um jogo 2D simples, onde uma nave voa no espaço e é atraída por coisas maciças. A velocidade da nave é armazenada em um vetor e a aceleração é aplicada a ela em todos os quadros, conforme apropriado, dada a lei da gravitação universal de Newton. As massas pontuais não se movem (há apenas 1 no momento), então eu esperaria uma órbita elíptica.

Em vez disso, vejo o seguinte:

Eu tentei com órbitas quase circulares e tentei tornar as massas muito diferentes (um fator de um milhão), mas sempre obtenho essa órbita girada.

Aqui está um código (D), para o contexto:

void accelerate(Vector delta)
{
    velocity = velocity + delta; // Velocity is a member of the ship class.
}

// This function is called every frame with the fixed mass. It's a
// method of the ship's.
void fall(Well well)
{
    // f=(m1 * m2)/(r**2)
    // a=f/m
    // Ship mass is 1, so a = f.
    float mass = 1;
    Vector delta = well.position - loc;
    float rSquared = delta.magSquared;
    float force = well.mass/rSquared;
    accelerate(delta * force * mass);
}

O bug está na fallfunção. Nós temos

1. delta: um vetor do poço para o navio
2. force: a magnitude da gravidade entre esses dois corpos.

|force| é G * m1 * m2 / r ^ 2

mas |delta|já é r! então você está acelerando muito rápido. Você precisa dividir rnovamente (basicamente normalizando o vetor delta) antes de chamar acelerar.

accelerate(delta * well.mass * mass / rSquared / Math.sqrt(rSquared))

Observe que, mesmo com o (s) bug (s) matemático (s) corrigido (s), você está usando a integração Euler (ou seja, velocity += deltae presumivelmente position += velocity), então provavelmente obterá alguns efeitos estranhos, como a rotação da elipse orbital ao longo do tempo, e talvez a elipse fique maior / menor, já que a integração com o Euler não garante economia de energia.

Você pode querer mudar para pular a integração , que economiza energia e deve funcionar melhor para a mecânica orbital. Além disso, você deve incluir o tempo do quadro em suas equações para que a velocidade da sua simulação seja independente da taxa de quadros.