Движение материальной точки в двумерном пространстве под действием постоянной силы

struct xyValues
{
    float x, y;
};
class MovedPoint 
{
    private:
        //текущее время, масса точки  
        float time, mass;
        // координаты, скорость   
        xyValues place, speed;
    public:
        // конструктор (time = 0)
        MovedPoint(xyValues p, float m);
        // Получить координаты
        xyValues GetPlace(void) const;
        // Получить скорости
        xyValues GetSpeed(void) const;
        // Переместить точку под действием постоянной 
        // силы в течение заданного промежутка времени
        void Move(xyValues force, float timeInterval); 
};

/////////////////////////////////////////////////////////////////////////////////////////
//Реализуйте и протестируйте класс MovedPoint, описывающий положение и движение 
//материальной точки в двумерном пространстве под действием постоянной силы. 
//При определении класса используйте структуру xyVa-lues:
//
/*
struct xyValues
{
float x, y;
};
class MovedPoint
{
private:
//текущее время, масса точки
float time, mass;
// координаты, скорость
xyValues place, speed;
public:
// конструктор (time = 0)
MovedPoint(xyValues p, float m);
// Получить координаты
xyValues GetPlace(void) const;
// Получить скорости
xyValues GetSpeed(void) const;
// Переместить точку под действием постоянной
// силы в течение заданного промежутка времени
void Move(xyValues force, float timeInterval);
};
*/
/////////////////////////////////////////////////////////////////////////////////////////
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::complex    < double    >   T_point_2;
typedef T_point_2                       T_vect_2;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_moving_point
{
    //-----------------------------------------------------------------------------------
    double      time_;
    double      mass_;
    T_point_2   location_;
    T_vect_2    velocity_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_moving_point
        (
            T_point_2   location,
            double      mass
        )
        :
        time_       (),
        mass_       ( mass      ),
        location_   ( location  ),
        velocity_   ()
    {}
    //-----------------------------------------------------------------------------------
    T_vect_2    get_velocity()                                                      const
    {
        return  velocity_;
    }
    //-----------------------------------------------------------------------------------
    T_point_2   get_location()                                                      const
    {
        return  location_;
    }
    //-----------------------------------------------------------------------------------
    double  get_time()                                                              const
    {
        return  time_;
    }
    //-----------------------------------------------------------------------------------
    double  get_mass()                                                              const
    {
        return  mass_;
    }
    //-----------------------------------------------------------------------------------
    void    move
        (
            T_vect_2    force,
            double      time_interval
        )
    {
        auto    acceleration    =   force / mass_;
 
        auto    delta_velocity  =       acceleration
                                    *   time_interval;
 
        location_               +=      velocity_
                                    *   time_interval;
 
        location_               +=      delta_velocity
                                    *   time_interval
                                    /   2.0;
 
        velocity_               +=  delta_velocity;
        time_                   +=  time_interval;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     get_rand_val_in_segment
    (
        int     L,
        int     R
    )
{
    return  rand() % ( R - L + 1 ) + L;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    T_moving_point  moving_point
                        (
                            T_point_2( 1, 2 ),
                            3
                        );
    for(;;)
    {
        std::cout   <<  "скорость и положение точки массой "
                    <<  moving_point.get_mass()
                    <<  " в момент времени "
                    <<  moving_point.get_time()
                    <<  ":"
                    <<  std::endl
                    <<  "v_cur = "
                    <<  moving_point.get_velocity()
                    <<  std::endl
                    <<  "r_cur = "
                    <<  moving_point.get_location()
                    <<  std::endl;
 
        system("pause");
 
        auto    F               =   T_vect_2
                                        (
                                            get_rand_val_in_segment( -10, 10 ),
                                            get_rand_val_in_segment( -10, 10 )
                                        );
 
        double  time_interval   =   get_rand_val_in_segment( 5, 20 );
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  "Применяя к точке силу F = "
                    <<  F
                    <<  std::endl
                    <<  "в течение интервала времени time_interval = "
                    <<  time_interval
                    <<  std::endl
                    <<  "получаем:"
                    <<  std::endl;
 
        moving_point.move
            (
                F,
                time_interval
            );
    }//for
}

class Force{
double Fx;
double Fy;
}
 
class Point{
  public:   
double x;
   double y;
   double Vx;
   double Vy;
   Fource F;
   double mass;
   void Tick();
}
 
void Point::Tick(){
   Vx = Vx + F.Fx*mass;
   Vy = Vy + F.Fy*mass;
   x = x + Vx;
   y = y + Vy;
}
 
Force Gravity(Point* p1; Point* p2){
 
  (p1->mass)*(p2->mass)/("расстояние в квадрате");
//и раскладываем по х и у
return;
}
 
int main(){
    Point p1, p2, p3;
//Задаём начальные положения и скорости
 
while (true){
  p1.F = Gravity(&p1, &p2) + Gravity(&p1, p3);
  p2.F = Gravity(&p2, &p1) + Gravity(&p2, p3);
  p3.F = Gravity(&p3, &p1) + Gravity(&p3, p2);
  p1. Tick();
  p2. Tick();
  p3. Tick();
//рисуем
 
}
 
 
 
 
 
return 0;
}