Updateto v1.2.2-Beta

18 September 2015
   Released version 1.2.2-Beta

     Change log:

-Fixed: Mouse line getting thinner the closer to vertical it gets

-Cleaned: Up a lot of code; made things simpler
  -Changed: All angles
are now in radians so I don't have to worry about converting
  -Changed:
Ball radius (and therefore mass) is now proportional to the amount of
time you held down the mouse button for.
  -Changed: Upped default
allowable number of cannonballs from 10 to 20

Author: Patrick Rye

ChangesLog.txt

@@ -1,3 +1,13 @@
+18 September 2015
+   Released version 1.2.2-Beta
+
+     Change log:
+        -Fixed: Mouse line getting thinner the closer to vertical it gets
+		-Cleaned: Up a lot of code; made things simpler
+		-Changed: All angles are now in radians so I don't have to worry about converting
+		-Changed: Ball radius (and therefore mass) is now proportional to the amount of time you held down the mouse button for.
+		-Changed: Upped default allowable number of cannonballs from 10 to 20
+
 17 September 2015
    Released version 1.2.1-Beta
 
@@ -16,7 +26,7 @@
 		-Changed: Default Min Velocity from 0.5 to 0.0 (basically disabling it)
 		-Changed: Disabled the Unrealistic method I added in 1.1.9-beta as it did not help.
 		-Fixed: Drag update acc would sometimes divide by 0
-		-Changed: Default Collision Method from Elastic to Ineleastic
+		-Changed: Default Collision Method from Elastic to Inelastic
 		-Changed: fMomentumLoss name to fCoefficientRestitution to be named after its real life counter part
 		-Added: Friction between the ball and floor / wall
 

src/cannonball.cpp

@@ -2,9 +2,6 @@
 #include "cannonball.h"
 #include "screen.h"
 /**********************************************************************************************************************************************/
-//Constants
-const double Rad_Convert = PI / 180.0;
-/**********************************************************************************************************************************************/
 clsCannonball::clsCannonball() {
     //Put some default values in; on the off chance I forget to set them later
     blnDragEnabled = false;
@@ -47,27 +44,23 @@ void clsCannonball::Drag_updateacc(void) {
         double Drag_Acc = (double) (Drag_Force / props.mass);
         double angle;
 
-        if (vel.x != 0.0) {angle = atan(vel.y / vel.x);}
-        else {angle = PI / 2.0;}
-
-        if (vel.x < 0.0) {angle += PI;}
+        angle = (vel.x != 0.0) ? atan(vel.y / vel.x) : PI / 2.0;
+        angle += vel.x < 0.0 ? PI : 0.0;
 
         acc.x += Drag_Acc * cos (angle);
         acc.y += Drag_Acc * sin (angle);
-
-        double Friction = (double)Global::Physics::fKineticFriction * (double)-1.0 * (double)Global::Physics::fGravity;
+        //Please recall fGravity is negative
+        double Friction = (double)Global::Physics::fKineticFriction * (double)Global::Physics::fGravity;
 
         //Update acc for Friction values
         if ( dblLOC.y <= Screen_place.h || dblLOC.y >= window.height ) {
             //Ball is in contact with floor or ceiling update x acc
-            if (vel.x < 0.0){acc.x += Friction;}
-            else {acc.x -= Friction;}
+            acc.x += Friction * (vel.x < 0.0 ? 1.0 : -1.0);
         }
 
         if ( dblLOC.x <= 0.0 || dblLOC.x >= window.width - Screen_place.w ) {
             //Ball is in contact with the wall update y acc.
-            if (vel.y < 0.0) {acc.y += Friction;}
-            else {acc.y -= Friction;}
+            acc.y += Friction * (vel.y < 0.0 ? 1.0 : -1.0);
         }
     } //end if things don't equal 0
 }
@@ -81,23 +74,18 @@ void clsCannonball::update(double newdeltat) {
 	vel.x = (vel.x + acc.x * deltat);
 	if (dblLOC.x <= 0.0 || dblLOC.x >= window.width - Screen_place.w) {
         vel.x *= Global::Physics::fRecoil;
-        if (dblLOC.x <= 0.0) {dblLOC.x++;}
-        else {dblLOC.x--;}
+        dblLOC.x += dblLOC.x <= 0.0 ? 1.0 : -1.0;
     } //end if hitting x edges
 
 	dblLOC.y = dblLOC.y + vel.y * deltat + 0.5 * acc.y * pow(deltat,2);
 	vel.y = (vel.y + acc.y * deltat);
 	if (dblLOC.y <= Screen_place.h || dblLOC.y >= window.height) {
         vel.y *= Global::Physics::fRecoil;
-        if (dblLOC.y <= Screen_place.h) {dblLOC.y++;}
-        else {dblLOC.y--;}
+        dblLOC.y += dblLOC.y <= Screen_place.y ? 1.0 : -1.0;
     }//end if hitting y edges
 
-    if (dblLOC.x < 0.0) {place.x = 0; dblLOC.x = 0;}
-    else {place.x = round(dblLOC.x);}
-
-    if (dblLOC.y < 0.0) {place.y = 0; dblLOC.y = 0;}
-    else {place.y = round(dblLOC.y);}
+    place.x = dblLOC.x < 0.0 ? 0 : round(dblLOC.x);
+    place.y = dblLOC.y < 0.0 ? 0 : round(dblLOC.y);
 
 	if (Global::Config.values.blnLogging) {
         FILE* logfile = fopen("logfile.log","a");
@@ -146,8 +134,8 @@ void clsCannonball::setValues(double r, LOC init_place, double init_vel, double
     dblLOC.x = (double) place.x;
     dblLOC.y = (double) place.y;
 
-    vel.x = (double)(init_vel) * (cos(init_angle * Rad_Convert));
-	vel.y = (double)(init_vel) * (sin(init_angle * Rad_Convert));
+    vel.x = (double)(init_vel) * (cos(init_angle));
+	vel.y = (double)(init_vel) * (sin(init_angle));
 
 	ballID = ID;
 	blnstarted = true;

src/config.cpp

@@ -40,8 +40,7 @@ clsConfig::clsConfig() {
 bool clsConfig::exists(void) {
 	//Returns true or false if config file exists
 	FILE* pTempFile = fopen(FileName, "r");
-	if (pTempFile == NULL) {return false;}
-	else {return true;}
+	return (pTempFile != NULL);
 }
 /**********************************************************************************************************************************************/
 void clsConfig::make(void) {
@@ -55,8 +54,8 @@ void clsConfig::make(void) {
 	//this way I only have to change the defaults in one place
     fprintf(configFile,"Screen Width: %u\n",values.uintScreenWidth);
     fprintf(configFile,"Screen Height: %u\n",values.uintScreenHeight);
-    fprintf(configFile,"Log Ball's path: 0\n");
-    fprintf(configFile,"Enable Drag Mode (experimental): 0\n");
+    fprintf(configFile,"Log Ball's path: %u\n", (values.blnLogging ? 1 : 0) ) ;
+    fprintf(configFile,"Enable Drag Mode (experimental): %u\n", (values.blnDragMode ? 1 : 0) );
 	fclose(configFile);
 }
 /**********************************************************************************************************************************************/
@@ -82,15 +81,13 @@ void clsConfig::load(void) {
 	intValuesScanned = sscanf(chrTempString, "%*s %*s %*s %d",&intTempBool);
 	if (intValuesScanned < 1) {printf("ERROR!"); intTempBool = 0;}
 	if(Global::blnDebugMode) {printf("Log Path \t %d\n",intTempBool);}
-	if(intTempBool == 1) {values.blnLogging = true;}
-	else {values.blnLogging = false;}
+	values.blnLogging = (intTempBool == 1);
 
     fgets(chrTempString,50,configFile);
 	intValuesScanned = sscanf(chrTempString, "%*s %*s %*s %*s %d",&intTempBool);
 	if (intValuesScanned < 1) {printf("ERROR!"); intTempBool = 0;}
 	if(Global::blnDebugMode) {printf("Enable Drag \t %d\n",intTempBool);}
-	if(intTempBool == 1) {values.blnDragMode = true;}
-	else {values.blnDragMode = false;}
+	values.blnDragMode = (intTempBool == 1);
 
 	fclose(configFile);
 	printf("\n\n");
@@ -116,7 +113,7 @@ char clsConfig::verisonCheck(const char *ConfigVerison) {
 void clsConfig::Check(void) {
 	char chrTempString[50], chrConfigVerison;
 
-	if (exists() != true) {
+	if ( !exists() ) {
 		printf("Config file was not found; creating now one\n");
 		make();
 	} else {

src/global.h

@@ -22,6 +22,7 @@ namespace Global {
         extern const float fVelocityScalar;
         extern const float fMinVelocity;
         extern const float fCoefficientRestitution;
+        extern const float fTimetoSizeRatio;
         extern const uchar CollisionMethod;
     }
 }

src/main.cpp

@@ -1,3 +1,7 @@
+/* TODO (GamerMan7799#4#): Show path of each ball on the screen */
+/* FIXME (GamerMan7799#1#): The balls will become stuck together for seemingly random reasons */
+/* TODO (GamerMan7799#1#): Balls are different colors based on their IDS */
+/* TODO (GamerMan7799#1#): Balls are more transparent the less mass it has. */
 /**********************************************************************************************************************************************************************/
 #include <SDL2/SDL.h>
 #include <cstdio>
@@ -10,7 +14,7 @@
 #include "tick.h"
 #include "config.h"
 /**********************************************************************************************************************************************************************/
-void addNewCannonball(LOC, LOC);
+void addNewCannonball(LOC, LOC, double);
 void checkForCollisons(uint);
 bool checkCollide(BOX, BOX);
 void doCollision(uint, uint);
@@ -36,17 +40,18 @@ namespace Global {
         //Friction values based on Concrete and Steel
         const float fKineticFriction = 0.36;
         const float fDensityAir = 1.2754; //Density of air
-        const float fRecoil = -0.56; //the mulitplier of the velocity when a ball hits the walls / floor
+        const float fRecoil = -0.56; //the multiplier of the velocity when a ball hits the walls / floor
         const float fVelocityScalar = 1; //Changing this effects the fire velocity
         const float fMinVelocity = 0.0; //If a ball has less velocity than the it will "die"
         const float fCoefficientRestitution = 0.76; //How much total energy remains after a collision
         //(see https://en.wikipedia.org/wiki/Coefficient_of_restitution for more info
+        const float fTimetoSizeRatio = 1.2458; //One second of holding down the mouse button = this many meters for the ball
         const uchar CollisionMethod = CollideInelastic;
     }
 }
 /**********************************************************************************************************************************************************************/
 //This is the maximum number of cannonballs which can be "alive" at a time
-#define DEFINED_CANNONBALL_LIMIT 10
+#define DEFINED_CANNONBALL_LIMIT 20
 /**********************************************************************************************************************************************************************/
 clsCannonball Cannonballs[DEFINED_CANNONBALL_LIMIT];
 /**********************************************************************************************************************************************************************/
@@ -79,21 +84,22 @@ int main(int argc, char *argv[]) {
             else if ( event.type == SDL_MOUSEBUTTONUP ) {
                 holding = false;
                 if (Global::blnDebugMode) {printf("Mouse button up\n");}
-                addNewCannonball(CurrentMouse, OldMouse);
+                addNewCannonball(CurrentMouse, OldMouse, Tick.stopHolding() );
             } else if ( event.type == SDL_MOUSEMOTION && holding) {
                 //Draw the line
                 SDL_GetMouseState(&CurrentMouse.x, &CurrentMouse.y );
                 if (Global::blnDebugMode) {printf("Mouse found at (%d,%d)\n",CurrentMouse.x,CurrentMouse.y);}
             } else if ( event.type == SDL_MOUSEBUTTONDOWN ) {
                 holding = true;
+                Tick.startHolding();
                 SDL_GetMouseState(&OldMouse.x, &OldMouse.y);
                 CurrentMouse = OldMouse;
                 if (Global::blnDebugMode) {printf("Mouse Button down at (%d,%d)\n",OldMouse.x,OldMouse.y);}
             } else if ( event.type == SDL_KEYDOWN ) {
                 switch ( event.key.keysym.sym ) {
                 case SDLK_k:
                     //kill all the balls
-                    for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) {Cannonballs[i].blnstarted = false;}
+                    for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) { Cannonballs[i].blnstarted = false; }
                     break;
                 case SDLK_q:
                 case SDLK_ESCAPE:
@@ -103,8 +109,7 @@ int main(int argc, char *argv[]) {
                 case SDLK_r:
                     //stop all motion of balls
                     dblXY StopVel;
-                    StopVel.x = 0.0;
-                    StopVel.y = 0.0;
+                    StopVel.x = StopVel.y = 0.0;
                     for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) { Cannonballs[i].setVelocity(StopVel); }
                     break;
                 } //end switch key
@@ -113,7 +118,6 @@ int main(int argc, char *argv[]) {
         if (holding) {CannonWindow.drawline(CurrentMouse, OldMouse);}
         //Update every ball
         tempdeltat = Tick.getTimeDifference();
-
 		for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) { //Loop through each cannonball
             if (Cannonballs[i].blnstarted) { //only update cannonball if it is "alive"
                 //Check for collisions if no collide is not on
@@ -123,29 +127,26 @@ int main(int argc, char *argv[]) {
 		} //end for loop
 
 		CannonWindow.update(); //Update the screen
-	} while (!quit);
+	} while (!quit); //keep looping until we get a quit
 	return 0;
 }
 /**********************************************************************************************************************************************************************/
-void addNewCannonball(LOC mouseC, LOC mouseO ) {
+void addNewCannonball(LOC mouseC, LOC mouseO, double HoldTime ) {
     //Get location, vel, and angle
     double fire_v;
     double angle;
+    double radius = (double)Global::Physics::fTimetoSizeRatio * HoldTime;
 
     //Because y increasing is going down according to SDL we first negative the velocity
     fire_v = -1 * sqrt( pow(mouseC.x - mouseO.x, 2) + pow(mouseC.y - mouseO.y, 2) );
     fire_v /= (double) Global::Physics::fVelocityScalar;
 
     //if the mouse if pointing straight up or straight down make the angle 90
-    //Other calculate the angle with atan.
+    //Otherwise calculate the angle with atan.
     if (mouseC.x == mouseO.x) {
-        if (mouseC.y > mouseO.y) {angle = -90.0;}
-        else if (mouseC.y < mouseO.y) {angle = 90.0;}
-        else {angle = 0.0;}
+        angle = (PI / 2.0) * ( (mouseC.y > mouseO.y) ? -1.0 : 1.0 );
     } else {
-        angle = (double)-1.0 * atan( (mouseC.y - mouseO.y) / (mouseC.x - mouseO.x) );
-        if (mouseC.x < mouseO.x) {angle += (double)PI;}
-        angle *= (double)(180.0/PI);
+        angle = (double) -1.0 * atan( (double)(mouseC.y - mouseO.y) / (double)(mouseC.x - mouseO.x) ) + (double)( (mouseC.x < mouseO.x) ? PI : 0.0 );
     } //end if x = x
 
     //mod mouse start, once again because the top left is 0,0 to SDL
@@ -154,12 +155,12 @@ void addNewCannonball(LOC mouseC, LOC mouseO ) {
     //loop through array to find next available cannonball slot
     for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) {
         if (!Cannonballs[i].blnstarted) {
-            Cannonballs[i].setValues(2.0, mouseO, fire_v, angle, i);
+            Cannonballs[i].setValues(radius, mouseO, fire_v, angle, i);
             return;
         } //end if not started
     } //end for cannonballs.
 
-    //since the program would have exited this function if a spot was open
+    //Since the program would have exited this function if a spot was open
     //below we tell the use they have to wait
     printf("You cannot add more cannonballs, please wait for some to decay.\n");
 }
@@ -200,11 +201,6 @@ void doCollision(uint numA, uint numB) {
     CenterA = Cannonballs[numA].getplace();
     CenterB = Cannonballs[numB].getplace();
 
-    CenterA.x += 5;
-    CenterA.y += 5;
-    CenterB.x += 5;
-    CenterB.y += 5;
-
     DeltaCenters.x = abs(CenterA.x - CenterB.x);
     DeltaCenters.y = abs(CenterA.y - CenterB.y);
     //Since it is r^2 and the sqrt of this give us r, we just drop the sqrt part to save time
@@ -234,23 +230,19 @@ void doCollision(uint numA, uint numB) {
         //get the angle for both A and B
         if (Avel.x != 0.0) {Aangle = atan(Avel.y/Avel.x);}
         else {
-            if (Avel.y > 0.0) {Aangle = PI / 2.0;}
-            else if (Avel.y < 0.0) {Aangle = - PI / 2.0;}
-            else {Aangle = 0.0;}
+            Aangle = (Avel.y >= 0.0) ? PI / 2.0 : -PI / 2.0;
         }
 
         if (Bvel.x != 0.0) {Bangle = atan(Bvel.y/Bvel.x);}
         else {
-            if (Bvel.y > 0.0) {Bangle = PI / 2.0;}
-            else if (Bvel.y < 0.0) {Bangle = - PI / 2.0;}
-            else {Bangle = 0.0;}
+            Bangle = (Bvel.y >= 0.0) ? PI / 2.0 : -PI / 2.0;
         }
 
         //Adjust the angle to be the right one.
         //Since atan will only yield a number between -PI/2 and PI/2 we
         //have to adjust it if xvel is negative.
-        if (Avel.x < 0.0) {Aangle += PI;}
-        if (Bvel.x < 0.0) {Bangle += PI;}
+        Aangle += Avel.x < 0.0 ? PI : 0;
+        Bangle += Bvel.x < 0.0 ? PI : 0;
         //The contact angle has to be the difference between the two angles but
         //since sometimes one or the other is negative, we'll use abs to ensure the right number
         ContactAngle = abs ( abs(Aangle) - abs(Bangle) );