Update to v1.4.0-RC.1

## [1.4.0-RC.1]
### Added
* Toolbar with different tools including: drag, fire, drop, rope, delete, and info. (Issue #5)
* Changable Ratio of meters to Pixels (default is 10 pixels/meter)

### Changed
* Disabled rope tool, still need to work on some of the equations. (Issue #4)
* Reduced kVelocityScalar from 1 -> 0.1
* Floors to casts (due to large number of calls of the floor functions).

### Removed
* Interia/engergy from spins, because it did nothing.

### Fixed
* Bug of balls getting stuck in walls.
* Bug of balls velocity becoming NaN. (Issue #3)

Author: GamerMan7799

LICENSE.md

@@ -3,26 +3,33 @@
 All notable changes to this project will be documented here.
 This project adheres to [Semantic Versioning](http://semver.org/)
 
-## [1.4.0-beta.6] - WIP
+## [1.4.0-RC.1] - WIP
 ### Added
-* Toolbar with different tools including: drag, fire, drop, rope, delete, and info. Not all are fully working at the moment. 
+* Toolbar with different tools including: drag, fire, drop, rope, delete, and info. (Issue #5)
 * Currently finished tools: fire, drag, drop, delete, and info.
-* Rope tool now creates rope between two balls or ball and wall. (Does nothing else at the moment)
 * SDL Licenses.
 * Credits to Docs.
 * More Doxygen stuff.
 * Debug message that prints ball mass when created. 
 * Ability to pause the simulation.
+* Changable Ratio of meters to Pixels (default is 10 pixels/meter)
 
 ### Changed
 * Moved Docs to Doc folder.
 * Moved various items out of main.cpp into core.cpp to avoid main becoming too large.
 * How balls are updated (order and a few equations) to make it hopefully more realistic. 
+* Increased ball size from 10x10 pixels to 25x25 pixels.
+* Various code improvements.
+* Disabled rope tool, still need to work on some of the equations. (Issue #4)
+* Reduced kVelocityScalar from 1 -> 0.1
+* Floors to casts (due to large number of calls of the floor functions).
 
+### Removed 
+* Interia/engergy from spins, because it did nothing.
 
-### Updated
-* Various code improvements.
-* Increased ball size from 10x10 pixels to 25x25 pixels.
+### Fixed
+* Bug of balls getting stuck in walls.
+* Bug of balls velocity becoming NaN. (Issue #3)
 
 ## [1.3.1-R] - 2018-03-16
 ### Added

docs/ChangesLog.md

@@ -168,7 +168,7 @@
 			<lib_finder disable_auto="1" />
 			<DoxyBlocks>
 				<comment_style block="5" line="0" />
-				<doxyfile_project project_number="v1.4.0-beta.2" output_directory="gh-pages" />
+				<doxyfile_project project_number="v1.4.0-R" output_directory="gh-pages" />
 				<doxyfile_build extract_all="1" />
 				<doxyfile_warnings />
 				<doxyfile_output />

project/Physics-Simulator.cbp

@@ -28,7 +28,6 @@ clsCannonball::clsCannonball() {
   deltat_ = (1.00 / 60.00);
   forces_ = {0,0};
   acc_ = {0.00, global::physics::kGravity};
-  spin_ = 1.0;
 
   props_.radius = 5.0; //in meters
   props_.density = global::physics::kBallDensity; //density of steel in kg/m^3
@@ -156,13 +155,6 @@ void clsCannonball::update(double newdeltat) {
 
     deltat_ = newdeltat;
 
-    if (blndragenabled_) {
-      doMagnusEffect();
-      dragUpdateAcc();
-    }
-    doFriction();
-    checkEdges();
-
     acc_.x = forces_.x / props_.mass;
     acc_.y = forces_.y / props_.mass;
 
@@ -172,6 +164,8 @@ void clsCannonball::update(double newdeltat) {
     dblLOC_.x += vel_.x * deltat_ /*+ 0.5 * acc_.x * pow(deltat_,2)*/;
     dblLOC_.y += vel_.y * deltat_ /*+ 0.5 * acc_.y * pow(deltat_,2)*/;
 
+    setEdgePosition();
+
     if (global::config.values.blnLogging) {
       FILE* logfile = fopen("logfile.log","a");
       fprintf(logfile,"Ball %3u \t (%.3f, %.3f)\n",ballID_, dblLOC_.x,dblLOC_.y);
@@ -191,7 +185,6 @@ void clsCannonball::update(double newdeltat) {
   updateCollisionBox();
 	show(); //show the ball on the screen
   // reset the forces so strange things don't happen
-  forces_ = {0.0, props_.mass * global::physics::kGravity};
 }
 /*****************************************************************************/
 void clsCannonball::show() {
@@ -256,12 +249,9 @@ void clsCannonball::setValues(double r, LOC init_place,
 
   acc_ = {0.00, global::physics::kGravity};
 
-  spin_ = (rand() % 1000 - 500) / 500;
-
-
   place_ = init_place;
-  dblLOC_ = { (double) place_.x,
-              (double) place_.y };
+  dblLOC_ = { (double) place_.x / global::physics::kMeterPixelRatio,
+              (double) place_.y / global::physics::kMeterPixelRatio};
 
   vel_ = { (double)(init_vel) * (cos(init_angle)),
            (double)(init_vel) * (sin(init_angle)) };
@@ -307,8 +297,8 @@ void clsCannonball::setplace(LOC newplace) {
   /////////////////////////////////////////////////
   /// @brief Set the ball's place
   /////////////////////////////////////////////////
-  dblLOC_.x = (double)newplace.x;
-  dblLOC_.y = (double)newplace.y;
+  dblLOC_.x = (double)newplace.x / global::physics::kMeterPixelRatio;
+  dblLOC_.y = (double)newplace.y / global::physics::kMeterPixelRatio;
 }
 /*****************************************************************************/
 void clsCannonball::setPhysicalProps(PP newprops) {
@@ -365,12 +355,12 @@ void clsCannonball::updateCollisionBox() {
   /////////////////////////////////////////////////
 
   // update place and collision box again in case something changed
-  place_.x = round(dblLOC_.x);
-  place_.y = round(dblLOC_.y);
+  place_.x = round(dblLOC_.x * global::physics::kMeterPixelRatio);
+  place_.y = round(dblLOC_.y * global::physics::kMeterPixelRatio);
 
 	//Update the collision box for the new location
-	collisionbox_.left = place_.x - floor(screen_place_.w / 2);
-	collisionbox_.top = screen::screenatt.height - (place_.y + floor(screen_place_.h / 2));
+	collisionbox_.left = place_.x - (int)(screen_place_.w / 2);
+	collisionbox_.top = screen::screenatt.height - (place_.y + (int)(screen_place_.h / 2));
 	collisionbox_.bottom = collisionbox_.top + screen_place_.h;
 	collisionbox_.right = collisionbox_.left + screen_place_.w;
 }
@@ -392,38 +382,12 @@ void clsCannonball::doFriction() {
   }
 }
 /*****************************************************************************/
-void clsCannonball::doMagnusEffect() {
-  /////////////////////////////////////////////////
-  /// @brief Calculates the Magnus Effect caused by the ball's spin
-  /////////////////////////////////////////////////
-
-  double magnus_force = pow(M_PI,2) * pow(props_.radius,3) *
-                        global::physics::kDensityAir;
-
-  forces_.x -= magnus_force * vel_.y * spin_;
-  forces_.y += magnus_force * vel_.x * spin_;
-}
-/*****************************************************************************/
 void clsCannonball::addForce(dblXY newforces) {
 
   forces_.x += newforces.x;
   forces_.y += newforces.y;
 }
 /*****************************************************************************/
-double clsCannonball::getSpin() {
-  /////////////////////////////////////////////////
-  /// @brief Returns the ball's spin
-  /////////////////////////////////////////////////
-  return spin_;
-}
-/*****************************************************************************/
-void clsCannonball::setSpin(double newspin) {
-  /////////////////////////////////////////////////
-  /// @brief Sets the ball's spin
-  /////////////////////////////////////////////////
-  spin_ = newspin;
-}
-/*****************************************************************************/
 void clsCannonball::writeInfo() {
   /////////////////////////////////////////////////
   /// @brief Writes information bout the ball to the console
@@ -436,7 +400,6 @@ void clsCannonball::writeInfo() {
   printf("Velocity: \t \t (%5.5f, %5.5f)\n",vel_.x,vel_.y);
   printf("Acceleration: \t \t (%5.5f, %5.5f)\n",acc_.x,acc_.y);
   printf("Forces: \t \t (%5.5f, %5.5f)\n", forces_.x, forces_.y);
-  printf("Spin: \t \t \t (%5.5f)\n\n\n", spin_);
 
 }
 /*****************************************************************************/
@@ -462,20 +425,16 @@ LOC clsCannonball::getScreenPlace() {
   /////////////////////////////////////////////////
   LOC temp;
   temp.x = screen_place_.x;
-  temp.x += floor (screen_place_.w/2);
+  temp.x += (int)(screen_place_.w/2);
   temp.y = screen_place_.y;
-  temp.y += floor(screen_place_.h/2);
+  temp.y += (int)(screen_place_.h/2);
   return temp;
 }
 /*****************************************************************************/
 void clsCannonball::checkEdges() {
   /////////////////////////////////////////////////
   /// @brief Checks and does stuff if ball is colliding with edges.
   /////////////////////////////////////////////////
-
-  /** @bug (GamerMan7799#1#): Balls appear to bounce forever because position is updated again after
-  running this function.  */
-
   // get new velocities if collision with edges
   double coefres = (global::config.values.uchrCollisionMethod == CollideInelastic) ?
                    global::physics::kCoefficientRestitution : 1.0;
@@ -484,28 +443,71 @@ void clsCannonball::checkEdges() {
     vel_.x *= -1 * coefres;
     vel_.y *= coefres;
     forces_.x = 0;
-    dblLOC_.x = screen_place_.w + 1;
   }
 
   if (collisionbox_.right > (screen::screenatt.width)) {
     vel_.x *= -1 * coefres;
     vel_.y *= coefres;
     forces_.x = 0;
-    dblLOC_.x = screen::screenatt.width - screen_place_.w / 2 - 1;
   }
 
   if (collisionbox_.bottom > (screen::screenatt.height)) {
     vel_.x *= coefres;
     vel_.y *= -1 * coefres;
     forces_.y = 0;
-    dblLOC_.y = screen_place_.h / 2 + 1;
   }
 
   if (collisionbox_.top < 0 ) {
     vel_.x *= coefres;
     vel_.y *= -1 * coefres;
     forces_.y = 2 * props_.mass * global::physics::kGravity;
-    dblLOC_.y = (screen::screenatt.height) - screen_place_.h / 2 - 1;
   }
 }
 /*****************************************************************************/
+void clsCannonball::setEdgePosition() {
+  /////////////////////////////////////////////////
+  /// @brief Set position if colliding with edges
+  /////////////////////////////////////////////////
+
+  if (collisionbox_.left < screen_place_.w / 2) {
+    dblLOC_.x = (screen_place_.w + 1);
+    dblLOC_.x /= global::physics::kMeterPixelRatio;
+  }
+
+  if (collisionbox_.right > (screen::screenatt.width)) {
+    dblLOC_.x = (screen::screenatt.width - screen_place_.w / 2 - 1);
+    dblLOC_.x /= global::physics::kMeterPixelRatio;
+  }
+
+  if (collisionbox_.bottom > (screen::screenatt.height)) {
+      dblLOC_.y = (screen_place_.h / 2 + 1 );
+      dblLOC_.y /= global::physics::kMeterPixelRatio;
+  }
+
+  if (collisionbox_.top < 0 ) {
+    dblLOC_.y = ((screen::screenatt.height) - screen_place_.h / 2 - 1);
+    dblLOC_.y /= global::physics::kMeterPixelRatio;
+  }
+}
+/*****************************************************************************/
+dblXY clsCannonball::getForces() {
+  /////////////////////////////////////////////////
+  /// @brief Returns forces on ball.
+  /////////////////////////////////////////////////
+
+  return forces_;
+}
+/*****************************************************************************/
+void clsCannonball::updateForces() {
+  /////////////////////////////////////////////////
+  /// @brief Updates all the forces on the ball.
+  /////////////////////////////////////////////////
+
+  forces_ = {0,props_.mass * global::physics::kGravity};
+
+  if (blndragenabled_) { dragUpdateAcc(); }
+  doFriction();
+  checkEdges();
+
+}
+/*****************************************************************************/

src/cannonball.cpp

@@ -75,18 +75,19 @@ class clsCannonball {
     LOC getplace(void);
     LOC getScreenPlace(void);
     void setplace(LOC);
-    void setSpin(double);
     void update(double);
+    void updateForces(void);
     dblXY getVelocity(void);
+    dblXY getForces(void);
     void setVelocity(dblXY);
     PP getPhysicalProps(void);
     void setPhysicalProps(PP);
     BOX getBOX(void);
-    double getSpin(void);
     void writeInfo(void);
     void togglePause(void);
     bool isPaused(void);
     void checkEdges(void);
+    void setEdgePosition(void);
     bool blnstarted_; /**< Whether or not the ball is "started" if it is, the program will update
         it and won't let a new ball replace it in its array spot. */
 
@@ -114,7 +115,6 @@ class clsCannonball {
         the movements looking realistic. See clsTick::getTimeDifference */
 
     dblXY forces_; /**< Forces on the ball in x and y */
-    double spin_; /**< The angular velocity of the ball (in rad/s) for the Magnus Effect  */
     bool paused_; /**< If the simulation is paused or not.  */
 
     void show(void);
@@ -123,7 +123,6 @@ class clsCannonball {
     void dragUpdateAcc(void);
     void doFriction(void);
     void updateCollisionBox(void);
-    void doMagnusEffect(void);
 };
 /*****************************************************************************/
 #endif // __CANNONBALL_HEADER__