平面物理引擎（我们的星星）2.1--源文件starx.cpp

源文件starx.cpp

包含头文件"vectorcals.h" 和 “starx.h”（starx（我们的星星）类）

vectorcals.h：https://blog.csdn.net/qq_33904382/article/details/102789672

/*源文件starx.cpp*/

#include "starx.h"
#include "vectorcals.h"//自建矢量处理库
#include<math.h>

starx::starx():
_mass(1),//质量
_radius(1),//半径
_location(2,0),//位置矢量
_force(2,0),//受力矢量
_velocity(2,0),//速度矢量
_acceleration(2,0)//加速度矢量
{
    //ctor
}

starx::starx(double locx,double locy):
_mass(1),//质量
_radius(1),//半径
_location(2,0),//位置矢量
_force(2,0),//受力矢量
_velocity(2,0),//速度矢量
_acceleration(2,0)//加速度矢量
{
    //ctor
    _location={locx,locy};
}

starx::starx(const double& locx,const double& locy,const double& vx,const double& vy):
_mass(1),//质量
_radius(1),//半径
_location(2,0),//位置矢量
_force(2,0),//受力矢量
_velocity(2,0),//速度矢量
_acceleration(2,0)//加速度矢量
{
    _location = {locx,locy};
    _velocity = {vx,vy};
}

starx::starx(const double& locx,const double& locy,const double& vx,const double& vy,const double& mass):
_mass(1),//质量
_radius(1),//半径
_location(2,0),//位置矢量
_force(2,0),//受力矢量
_velocity(2,0),//速度矢量
_acceleration(2,0)//加速度矢量
{
    _location = {locx,locy};
    _velocity = {vx,vy};
    _mass = mass;
}

starx::~starx()
{
    //dtor
}

//计算并返回starx对象受到的合引力
void starx::gravitation(const vector<starx>& otherstarxs)
{
    _force[x]=0;_force[y]=0;//清零力 准备再次计算受力情况
    double fu,fd,f;
    for(auto elem : otherstarxs){
            fu = G*(_mass)*(elem._mass);
            fd = distance2(elem);//距离平方
            f = fu/fd;       //单个引力大小<模长>
            auto vecdiff = vecdirx( vecroad(elem) );//获取本->目标点<施力者>单位方向向量
                                                    //此时应当是vector<double>类型
            vecdiff[x] = vecdiff[x]*f;
            vecdiff[y] = vecdiff[y]*f;//方向+力-->矢量化的力
            //保存力<所有力的矢量和>
            _force[x] += vecdiff[x];
            _force[y] += vecdiff[y];
    }

}

//计算并保存两坐标轴方向上的加速度
void starx::accelerate()
{
    _acceleration[x] = _force[x]/_mass;
    _acceleration[y] = _force[y]/_mass;
}

//计算速度变化量并更新速度 <传入上次计算到这次前瞬间的时间变化量>
void starx::velocity(const double& dtime)
{
    _velocity[x] += dtime * _acceleration[x];
    _velocity[y] += dtime * _acceleration[y];
}

//计算并更新坐标信息  <传入时间该改变量>
void starx::kinesis(const double& dtime)
{
    _location[x] += dtime * _velocity[x];
    _location[y] += dtime * _velocity[y];
}

//返回指定的坐标值
double starx::location(const int var)const
{
    return _location[var];//0-x;1-y;
}



//计算两星距离 <二维平面欧氏距离>
double starx::distance(const starx& B)
{
    double dx = (B.location(x)-this->location(x));//x坐标差
    double dy = (B.location(y)-this->location(y));//y坐标差
    return sqrt(dx*dx+dy*dy);//返回距离
}
//计算两星距离 <二维平面欧氏距离>
double starx::distance2(const starx& B)
{
    double dx = (B.location(x)-this->location(x));//x坐标差
    double dy = (B.location(y)-this->location(y));//y坐标差
    return dx*dx+dy*dy;//返回距离平方
}

//计算两星星在平面坐标系中的位置矢量 差矢量
vector<double> starx::vecroad(const starx& Another)
{
    vector<double> diff;
    diff.push_back((Another.location(x)-this->location(x)));
    diff.push_back((Another.location(y)-this->location(y)));
    return diff;
}

//返回指定坐标轴方向的速度速度
double starx::speed(const int var)
{
    return _velocity[var];
}

//返回指定坐标轴方向上的合力<向量>坐标
double starx::force(const int var)
{
    return _force[var];
}