Hey all,
I have a list of classes enclosed in a class:
Code:
/* The controling class of the whole program. Calls the functions responsible for displacement calculation and object rendering,
* as well as containing the list of ClStar objects
*/
#ifndef CLASS_UNIVERSE_H
#define CLASS_UNIVERSE_H
#include <list>
#include <iostream>
#include "ClassStar.h"
#include "ClassValues.h"
#include "ClassMath.h"
#include "ClassGravCalculator.h"
#include "ClassRender.h"
#include "ClassPosRegulator.h"
using namespace std;
class ClUniverse {
private:
list<ClStar> m_Stars;
ClPosRegulator m_ClPosReg;
ClGravCalculator m_ClGravCalc;
public:
ClUniverse();
void calculateDisplacement();
void drawObjects();
};
#endif
Code:
#include "ClassUniverse.h"
ClUniverse::ClUniverse() : m_Stars(ClValues::nNumObjects)
{}
void ClUniverse::calculateDisplacement()
{
list<ClStar>::iterator it_NxtStar;
for(list<ClStar>::iterator it_CurStar = m_Stars.begin(); it_CurStar != m_Stars.end(); it_CurStar++) {
it_NxtStar = it_CurStar;
it_NxtStar++;
while(it_NxtStar != m_Stars.end()) {
m_ClGravCalc(*it_CurStar, *it_NxtStar);
cout << it_CurStar->getPosition().getX() << endl;
cout << it_CurStar->getPosition().getY() << endl;
cout << it_NxtStar->getPosition().getX() << endl;
cout << it_NxtStar->getPosition().getY() << endl;
cout << endl;
it_NxtStar++;
}
m_ClPosReg(*it_CurStar);
}
}
void ClUniverse::drawObjects()
{
clear(ClValues::dblbuffer);
drawing_mode(DRAW_MODE_TRANS, 0, 0, 0);
for(list<ClStar>::iterator it_CurStar = m_Stars.begin(); it_CurStar != m_Stars.end(); it_CurStar++)
ClRender(ClValues::dblbuffer, it_CurStar->getPosition(), it_CurStar->getRadius());
vsync();
blit(ClValues::dblbuffer, screen, 0, 0, 0, 0, ClValues::nScreenHight, ClValues::nScreenWidth);
}
Here are the ClStar files:
Code:
/* This file contains the declarations for ClStar. It contains variables to hold all the necessary data to simulate gravitation displacement
* between stars using classical mechanics
*/
#ifndef CLASS_STARS_H
#define CLASS_STARS_H
#include <cmath>
#include "ClassMath.h"
#include "ClassVector.h"
#include "ClassValues.h"
#include "ClassRange.h"
class ClStar {
private:
//Mass
long double m_dMass;
//Density
long double m_dDensity;
//Radius
long double m_dRadius;
//Position vector
ClVector m_vecPosition;
//Velocity vector
ClVector m_vecVelocity;
//The number of stars
static int s_nNumStars;
//---------------------------------------------
/*//Next node in linked list
ClStar* m_nextnode;*/
//---------------------------------------------
public:
//Constructor, will use vales from the class ClValues
//ClStar(int nNumNodes);
ClStar();
//Access functions
long double getMass();
long double getDensity();
long double getRadius();
ClVector getPosition();
ClVector getVelocity();
void setPosition(ClVector vecPosition);
void setPosition(long double dX, long double dY);
void addPosition(ClVector vecPosition);
void addPosition(long double dX, long double dY);
void setVelocity(ClVector vecVelocity);
void setVelocity(long double dX, long double dY);
void addVelocity(ClVector vecVelocity);
void addVelocity(long double dX, long double dY);
//ClStar* getNextNode();
};
#endif
Code:
#include "ClassStar.h"
int ClStar::s_nNumStars = 0;
/*ClStar::ClStar(int nNumNodes) : m_nextnode(0)
{
//Generate random values for mass and density, using ranges found in ClValues,
//and compute the radius. This program treats the objects as spheres.
m_dMass = ClMath::randNum(ClValues::rnMass);
m_dDensity = ClMath::randNum(ClValues::rnDensity);
m_dRadius = std::pow((m_dMass/m_dDensity) / (4 * ClMath::dPI / 3), static_cast<long double>(1.0/3.0));
//Get the sequence number of current node. Starts at 1
int nCurNode = ClValues::nNumObjects - nNumNodes + 1;
//The screen will be divided into "quadrants" to lower the chances of two stars sharing coordinates. One quadrant will be as
//high as the screen, and as wide as ScrWidth/NumObjects
int nQuadrantWidth = static_cast<int>(floor(ClValues::nScreenWidth / ClValues::nNumObjects));
ClRange<long int> rngWidth(nQuadrantWidth * (nCurNode - 1), nQuadrantWidth * nCurNode - 1);
ClRange<long int> rngHight(0, ClValues::nScreenHight);
//Generate coordinates
m_vecPosition.setVector(static_cast<long double> (ClMath::randNum(rngHight)), static_cast<long double> (ClMath::randNum(rngWidth)));
//Create new node if needed ammount has not yet been reached
if(nNumNodes - 1)
m_nextnode = new ClStar(nNumNodes - 1);
}*/
ClStar::ClStar()
{
//Generate random values for mass and density, using ranges found in ClValues,
//and compute the radius. This program treats the objects as spheres.
m_dMass = ClMath::randNum(ClValues::rnMass);
m_dDensity = ClMath::randNum(ClValues::rnDensity);
m_dRadius = std::pow((m_dMass/m_dDensity) / (4 * ClMath::dPI / 3), static_cast<long double>(1.0/3.0));
//Number of the star
int nCurNode = ++s_nNumStars;
//The screen will be divided into "quadrants" to lower the chances of two stars sharing coordinates. One quadrant will be as
//high as the screen, and as wide as ScrWidth/NumObjects
long int nQuadrantWidth = static_cast<long int>(floor(ClValues::nScreenWidth / ClValues::nNumObjects));
ClRange<long int> rngWidth(nQuadrantWidth * (nCurNode - 1), nQuadrantWidth * nCurNode - 1);
ClRange<long int> rngHight(0, ClValues::nScreenHight);
//Generate coordinates
m_vecPosition.setVector(static_cast<long double> (ClMath::randNum(rngHight)), static_cast<long double> (ClMath::randNum(rngWidth)));
}
long double ClStar::getMass()
{
return m_dMass;
}
long double ClStar::getDensity()
{
return m_dDensity;
}
long double ClStar::getRadius()
{
return m_dRadius;
}
ClVector ClStar::getPosition()
{
return m_vecPosition;
}
ClVector ClStar::getVelocity()
{
return m_vecVelocity;
}
void ClStar::setPosition(ClVector vecPosition)
{
m_vecPosition = vecPosition;
}
void ClStar::setPosition(long double dX, long double dY)
{
ClVector vec(dX, dY);
m_vecPosition = vec;
}
void ClStar::addPosition(ClVector vecPosition)
{
m_vecPosition += vecPosition;
}
void ClStar::addPosition(long double dX, long double dY)
{
ClVector vec(dX, dY);
m_vecPosition += vec;
}
void ClStar::setVelocity(ClVector vecVelocity)
{
m_vecVelocity = vecVelocity;
}
void ClStar::setVelocity(long double dX, long double dY)
{
ClVector vec(dX, dY);
m_vecVelocity = vec;
}
void ClStar::addVelocity(ClVector vecVelocity)
{
m_vecVelocity += vecVelocity;
}
void ClStar::addVelocity(long double dX, long double dY)
{
ClVector vec(dX, dY);
m_vecVelocity += vec;
}
Problem is, all the "stars" get generated with exactly the same coordinates. Before, when I made my own linked list, the code worked fine. But when I rewrote the code to use lists instead, it doesn't work anymore. Any tips as to why this is happening?
Cheers,
Gabe
PS.: Ignore anything that's commented out, it's just the old code using linked lists. And sorry for the debug stuff that's strewn all over the place.