Неуловимая ошибка в коде программы

#pragma comment(lib,"Opengl32.lib")
#pragma comment(lib,"Glu32.lib")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"Glaux.lib")
 
 
#include <gl\freeglut.h>
#include <math.h>
#include <vector>
#include <stdint.h>
 
int totalBalls = 10;
 
void reshape(int w, int h)
{
    glViewport(0, 0, w, h);        
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, w, 0, h);        
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
 
class Vector2D {
    private:
        double x;
        double y;
    public:
    Vector2D() {
    }
    Vector2D(double valueX, double valueY) {
        x = valueX;
        y = valueY;
    }
    
    void setvecX(double valueX) {
        x = valueX;
    }
 
    double getvecX() {
        return x;
    }
 
    void setvecY(double valueY) {
        y = valueY;
    }
    double getvecY() {
        return y;
    }
    void setVector(double valueX, double valueY){
        x = valueX;
        y = valueY;
    }
    void reset(){
        x = 0;
        y = 0;
    }
    double getMagnitude(){
        double lengthX = x;
        double lengthY = y;
        return sqrt(lengthX * lengthX +lengthY * lengthY*1.0);
    }
    double getAngle(){
        double lengthX = x;
        double lengthY = y;
        return atan2(lengthY, lengthX*1.0);
    }
    Vector2D duplicate(){
        Vector2D dup(x, y);
        return dup;
    }
    Vector2D getVectorDirection(){
        Vector2D vectorDirection(x/getMagnitude(), y/getMagnitude());
        return Vector2D(vectorDirection); ///////////???????
    }
    void minusVector(Vector2D vector2){
        x -= vector2.getvecX();
        y -= vector2.getvecY();
    }       
    void addVector(Vector2D vector2){
        x += vector2.getvecX();
        y += vector2.getvecY();
    }       
    void multiply (int scalar){
        x *= scalar;
        y *= scalar;
    }
};
class Ball {
    private:
        Vector2D disp;
        Vector2D velo;
        Vector2D acc;
        int mass;
    public:
        double x;
        double y;
        int width;
        int name;
 
    Ball(int radius = 20, uint32_t color = 0x0000FF) {
        draw(radius, color);
        mass = radius / 2; //принимаем массу - половина радиуса
        x = rand() % 550;
        y = rand() % 400;
        disp.setVector(x, y); //установим начальное перемещение
        velo.setVector(0, 0);
        acc.setVector(0, 0);
    }
    void draw(int radius, uint32_t color)
    {
        //display();//Для отображения используется таймер
    }
    int getmass()
    {
        return mass;
    }
    Vector2D getForceAttract(int m1, int m2, Vector2D vec2Center)
    {
        //вычисляем силу притяжения, основанную на следующей формуле:  * F = K * m1 * m2 / r * r
        
        double numerator = 500 * m1 * m2; // attractive_coeff = 500
        double denominator = vec2Center.getMagnitude() * vec2Center.getMagnitude();
        double forceMagnitude = numerator / denominator;
        double forceDirection = vec2Center.getAngle();
                    
        //установка верхнего предела
        if (forceMagnitude > 0) forceMagnitude = (forceMagnitude < 5) ? forceMagnitude : 5;
                    
        //получаем горизонтальную и вертикальную составляющие силы
        double forceX = forceMagnitude * cos(forceDirection);
        double forceY = forceMagnitude * sin(forceDirection);
        Vector2D force(forceX, forceY);     
        return force;
    }
    Vector2D getAcc(Vector2D vecForce)
    {
        //установим ускорение в зависимости от силы
        vecForce.multiply(1 /mass);
        Vector2D vecAcc = vecForce.duplicate();
        return vecAcc;
    }
    Vector2D getDispTo(Ball ball)
    {
        Vector2D currentVector(ball.x, ball.y);
        currentVector.minusVector(disp);
        return currentVector;
    }
    void attractedTo(Ball ball)
    {
        Vector2D toCenter = getDispTo(ball);
        Vector2D currentForceAttract = getForceAttract(ball.mass, mass, toCenter);
        acc = getAcc(currentForceAttract);
        velo.addVector(acc);
        disp.addVector(velo);
    }
    void setPosition(Vector2D vecDisp)
    {       
        x = floor(vecDisp.getvecX() + 0.5); //Округляем в сторону ближайшего целого значения
        y = floor(vecDisp.getvecY() + 0.5);
    }
    bool collisionInto(Ball ball)
    {
        bool hit = false;
        int minDist = (ball.width + width) / 2;
        if (getDispTo(ball).getMagnitude() < minDist) hit = true;
        return hit;
    }
    Vector2D getRepel(Ball ball)
    {
        int minDist = (ball.width + width) / 2;     
        Vector2D toBall = getDispTo(ball); //вычислим расстояние для отскока
        Vector2D directToBall = toBall.getVectorDirection();
        directToBall.multiply(minDist);
        directToBall.minusVector(toBall);
        directToBall.multiply( -1);
        return directToBall;
    }       
    void repelledBy(Ball ball)
    {
        acc.reset();
        velo.reset();
        Vector2D repelDisp = getRepel(ball);
        disp.addVector(repelDisp);
    }       
    void animate(Ball center, std::vector<Ball> all)
    {
        attractedTo(center);
        if (collisionInto(center)) repelledBy(center);
        for (uint32_t i = 0; i < all.size(); i++)
        {
            Ball current_ball = all[i];
            if (collisionInto(current_ball) && current_ball.name != name) repelledBy(current_ball);
        }
        setPosition(disp);
    }
    void setName(int n) {
        name = n;
    }
};
 
 
Ball mainBall;
std::vector<Ball> Children;
 
void display()
{
        glClear(GL_COLOR_BUFFER_BIT);
        for (uint32_t i = 0; i <= totalBalls; i++){
            Ball ball = Children[i];
            float X = ball.x;
            float Y = ball.y;
            float Radius = ball.getmass();
            glColor3f (1, 0.5, 0);  // Круги оранжевого цвета
            glBegin (GL_POLYGON);
            for (double angle = 0 ; angle <=6.28318531; angle +=0.01) { //  Рисуем круг
                glVertex2f (X + sin((float)angle) * Radius, Y + cos((float)angle) * Radius);
            }
            glEnd();
        }        
        glutSwapBuffers();
 }
 
class Main
{
    private:
        Ball mainBall;
        uint32_t totalBalls;
    public:
    Main(){
        totalBalls = 10;
        init();
    }
    void addChild(Ball ball){
        Children.push_back(ball);
    }
    Ball getChildAt(int i){
        return Children[i];
    }
    void createBalls () {
        Ball mainBall(50, 0x00FF00);
        addChild(mainBall);
        for (uint32_t i = 0; i < totalBalls; i++) 
        {
            Ball currentBall;
            currentBall.setName(i);
            addChild(currentBall);
        }
    }
    
    void init(){
        createBalls();
        animateAll();
    }   
    void enterFrame() 
    {
        for (uint32_t i = 0; i <= totalBalls; i++){
            std::vector<Ball> allObj;
            for (uint32_t j = 0; j <= totalBalls; j++){
                Ball current_ball = getChildAt(j);
                allObj.push_back(current_ball);
            }
            getChildAt(i).animate(mainBall, allObj);
        }
    }
    void animateAll()
    {
        for (uint32_t i = 0; i < totalBalls; i++)
        {           
            Ball current_ball = getChildAt(i); //каждый шар притягивается main_ball
            enterFrame();
        }
    }
    
};
Main m;
 
void timer(int = 0)
{
    m.enterFrame();
    glutTimerFunc(5000, timer, 0);
    display();
}
 
int main (int argc, char * argv[])
 {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA); /*Включаем двойную буферизацию и четырехкомпонентный цвет*/
        
        glutInitWindowSize(800, 600);
        glutCreateWindow("Balls");
        
        glutReshapeFunc(reshape);
        glutDisplayFunc(display);
        timer();
        
        glutMainLoop();
  
        return 0;
 }