Update to v1.1.8-beta

16 September 2015
   Released version 1.1.8-Beta

     Change log:

-Added: More collision methods (Inelastic, Elastic, Perfect Inelastic,
and No Collisons)
  -Improved: Collision equations
  -Fixed: You can now
properly fire a cannonball in all directions
  -Fixed: Balls that have
velocity as NaN will be removed
     (I should have fixed the equations
so this doesn't happen, but just is cause)

Author: Patrick Rye

ChangesLog.txt

@@ -1,5 +1,15 @@
+16 September 2015
+   Released version 1.1.8-Beta
+
+     Change log:
+        -Added: More collision methods (Inelastic, Elastic, Perfect Inelastic, and No Collisons)
+		-Improved: Collision equations
+		-Fixed: You can now properly fire a cannonball in all directions
+		-Fixed: Balls that have velocity as NaN will be removed 
+		   (I should have fixed the equations so this doesn't happen, but just is cause)
+
 15 September 2015
-   UNFINISHED Released version 1.1.7-Beta
+   Released version 1.1.7-Beta
 
      Change log:
         -Added: Collisons

src/cannonball.cpp

@@ -2,8 +2,6 @@
 #include "cannonball.h"
 #include "screen.h"
 /**********************************************************************************************************************************************/
-#define PI 3.1415926535897
-/**********************************************************************************************************************************************/
 //Constants
 const double Rad_Convert = PI / 180.0;
 /**********************************************************************************************************************************************/
@@ -90,7 +88,7 @@ void clsCannonball::update(double newdeltat) {
 
     double total_v;
     total_v = sqrt( pow(vel.x,2) + pow(vel.y,2) );
-    if (total_v < Global::Physics::fMinVelocity) {
+    if (total_v < Global::Physics::fMinVelocity || isnan(total_v) ) {
             blnstarted = false;
             if (Global::blnDebugMode) {printf("Ball moving too slow; killing it\n");}
     }
@@ -139,12 +137,16 @@ void clsCannonball::setVelocity(dblXY newvel) {
     vel.y = newvel.y;
 }
 /**********************************************************************************************************************************************/
-double clsCannonball::getmass() {
-    return props.mass;
+PP clsCannonball::getPhysicalProps() {
+    return props;
 }
 /**********************************************************************************************************************************************/
 void clsCannonball::setplace(LOC newplace) {
     dblLOC.x = newplace.x;
     dblLOC.y = newplace.y;
 }
 /**********************************************************************************************************************************************/
+void clsCannonball::setPhysicalProps(PP newprops) {
+    props = newprops;
+}
+/**********************************************************************************************************************************************/

src/cannonball.h

@@ -9,6 +9,8 @@
 #include "global.h"
 #include "screen.h"
 /**********************************************************************************************************************************************/
+#define PI 3.1415926535897
+/**********************************************************************************************************************************************/
 struct stcDoubleValues {
     double x;
     double y;
@@ -28,17 +30,18 @@ class clsCannonball {
     public:
         /** Default constructor */
         clsCannonball();
-        bool blnstarted;
         void setValues(double, LOC, double, double);
         LOC getplace(void);
         void setplace(LOC);
 
-        void enableDrag(void);
         void update(double);
         void setSDLScreen(SDL_Texture*, WINATT);
         dblXY getVelocity(void);
         void setVelocity(dblXY);
-        double getmass(void);
+        PP getPhysicalProps(void);
+        void setPhysicalProps(PP);
+
+        bool blnstarted;
     private:
         bool blnDragEnabled;
 
@@ -51,6 +54,7 @@ class clsCannonball {
         dblXY acc;
         PP props;
 
+        void enableDrag(void);
         double deltat;
         void show(void);
         void Drag_calcvalues(void);

src/global.h

@@ -11,7 +11,7 @@ typedef unsigned long ulong;
 //Global namespace
 namespace Global {
     extern const bool blnDebugMode;
-    extern clsConfig Config;
+    extern clsConfig Config; //Hold the config file globally so configure options can be referenced everywhere
     namespace Physics { //hold physics values in one place for future reference
         extern const uint uBallDensity;
         extern const float fGravity;
@@ -21,6 +21,7 @@ namespace Global {
         extern const float fVelocityScalar;
         extern const float fMinVelocity;
         extern const float fMomentumLoss;
+        extern const uchar CollisionMethod;
     }
 }
 /**********************************************************************************************************************************************/

src/main.cpp

@@ -24,6 +24,13 @@ bool checkCollide(BOX, BOX);
 void doCollision(uint, uint);
 BOX boxMaker(LOC);
 /**********************************************************************************************************************************************************************/
+enum Collisions { //The method of the collision (I just wanted to play around with some options.
+    CollideElastic = 0, //This is the normal way things collide, they hit and bounce off, no energy is lost
+    CollideInelastic, //balls collide and bounce off of each other losing some energy.
+    CollidePerfectInelastic, //In this method the balls collide and then stick together
+    CollideNone //No collisions
+};
+/**********************************************************************************************************************************************************************/
 namespace Global {
 #ifdef DEFINED_BUILD_MODE_PRIVATE
     const bool blnDebugMode = true;
@@ -38,14 +45,13 @@ namespace Global {
         const float fDensityAir = 1.2754; //Density of air
         const float fRecoil = -0.56;
         const float fVelocityScalar = 1; //Changing this effects the fire velocity
-        const float fMinVelocity = 0.005; //If a ball has less velocity than the it will "die"
-        const float fMomentumLoss = 1; //How much total momentum stays after a collisions
+        const float fMinVelocity = 0.5; //If a ball has less velocity than the it will "die"
+        const float fMomentumLoss = 0.76; //How much total momentum stays after a collisions
+        const uchar CollisionMethod = CollideElastic;
     }
 }
 /**********************************************************************************************************************************************************************/
-/* TODO (GamerMan7799#1#): Figure out how to detect the edges of the images */
-/* TODO (GamerMan7799#1#): Get Highest height and Distance from fire at end of run. */
-/**********************************************************************************************************************************************************************/
+//This is the maximum number of cannonballs which can be "alive" at a time
 #define DEFINED_CANNONBALL_LIMIT 10
 /**********************************************************************************************************************************************************************/
 clsCannonball Cannonballs[DEFINED_CANNONBALL_LIMIT];
@@ -69,7 +75,8 @@ int main(int argc, char *argv[]) {
     LOC OldMouse, CurrentMouse;
     SDL_Event event;
 	do {
-        CannonWindow.clearscreen();
+        CannonWindow.clearscreen(); //Clear the screen so new stuff can be drawn
+
         //poll events
         if (SDL_PollEvent( &event ) != 0) {
             if ( event.type == SDL_QUIT ) {quit = true;}
@@ -91,13 +98,16 @@ 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++) {
-            if (Cannonballs[i].blnstarted) {
+
+		for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) { //Loop through each cannonball
+            if (Cannonballs[i].blnstarted) { //only update cannonball if it is "alive"
                 Cannonballs[i].update(tempdeltat);
-                checkForCollisons(i);
+                //Check for collisions if no collide is not on
+                if (Global::Physics::CollisionMethod != CollideNone) {checkForCollisons(i);}
             } //end if started
 		} //end for loop
-		CannonWindow.update();
+
+		CannonWindow.update(); //Update the screen
 	} while (!quit);
 	return 0;
 }
@@ -107,20 +117,23 @@ void addNewCannonball(LOC mouseC, LOC mouseO ) {
     double fire_v;
     double angle;
 
+    //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.
     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;}
     } else {
         angle = (double)-1.0 * atan( (mouseC.y - mouseO.y) / (mouseC.x - mouseO.x) );
-        angle *= (double)(180/3.1415926535);
-        if (mouseC.x < mouseO.x) {angle *= (double)-1.0;}
+        if (mouseC.x < mouseO.x) {angle += (double)PI;}
+        angle *= (double)(180/PI);
     } //end if x = x
 
-    //mod mouse start
+    //mod mouse start, once again because the top left is 0,0 to SDL
     mouseO.y = tempwin.height - mouseO.y;
 
     //loop through array to find next available cannonball slot
@@ -159,32 +172,110 @@ bool checkCollide(BOX A, BOX B) { //checks if two objects (made with the BOXES c
 /**********************************************************************************************************************************************************************/
 void doCollision(uint numA, uint numB) {
     dblXY Avel, Bvel, NewVel;
-    double Amass, Bmass;
+    PP Aprops, Bprops;
+
     Avel = Cannonballs[numA].getVelocity();
     Bvel = Cannonballs[numB].getVelocity();
-    Amass = Cannonballs[numA].getmass();
-    Bmass = Cannonballs[numB].getmass();
+    Aprops = Cannonballs[numA].getPhysicalProps();
+    Bprops = Cannonballs[numB].getPhysicalProps();
+
+    double Aangle, Bangle, ContactAngle;
+    double Atotal_v, Btotal_v;
 
-    double totalMomX = Amass * Avel.x - Bmass * Bvel.x;
-    double totalMomY = Amass * Avel.y - Bmass * Bvel.y;
-    totalMomX *= (double)Global::Physics::fMomentumLoss;
-    totalMomY *= (double)Global::Physics::fMomentumLoss;
+    dblXY TotalAMomentum, TotalBMomentum;
 
-    //I know that this is not a true Momentum equation
-    //I'm just trying to get something up to test things out.
-    NewVel.x = totalMomX / (Amass + Bmass);
-    NewVel.y = totalMomY / (Amass + Bmass);
+    if ( Global::Physics::CollisionMethod != CollidePerfectInelastic ) {
+        //The equations for Perfect Inelastic is much simpler than if not
+        //so I am handling those a bit differently to speed up that method.
+
+        //Equations used can be found and explained here: https://en.wikipedia.org/wiki/Elastic_collision
+        Atotal_v = sqrt( pow(Avel.x,2) + pow(Avel.y,2) );
+        Btotal_v = sqrt( pow(Bvel.x,2) + pow(Bvel.y,2) );
+
+        //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;}
+        }
+
+        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;}
+        }
+
+        //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;}
+        ContactAngle = Aangle + Bangle;
+
+        TotalAMomentum.x = Atotal_v * cos(Aangle - ContactAngle) * (Aprops.mass - Bprops.mass);
+        TotalAMomentum.x += 2.0 * Bprops.mass * Btotal_v * cos(Bangle - ContactAngle);
+        TotalAMomentum.x /= (Aprops.mass + Bprops.mass);
+        //x and y formulas are the same until this point
+        TotalAMomentum.y = TotalAMomentum.x;
+        TotalAMomentum.x *= cos(ContactAngle);
+        TotalAMomentum.y *= sin(ContactAngle);
+        TotalAMomentum.x += Atotal_v * sin(Aangle - ContactAngle) * cos(ContactAngle + (PI/2.0) );
+        TotalAMomentum.y += Atotal_v * cos(Aangle - ContactAngle) * cos(ContactAngle + (PI/2.0) );
+
+        //Now do B
+        TotalBMomentum.x = Btotal_v * cos(Bangle - ContactAngle) * (Bprops.mass - Aprops.mass);
+        TotalBMomentum.x += 2.0 * Aprops.mass * Atotal_v * cos(Aangle - ContactAngle);
+        TotalBMomentum.x /= (Aprops.mass + Bprops.mass);
+        //x and y formulas are the same until this point
+        TotalBMomentum.y = TotalBMomentum.x;
+        TotalBMomentum.x *= cos(ContactAngle);
+        TotalBMomentum.y *= sin(ContactAngle);
+        TotalBMomentum.x += Btotal_v * sin(Bangle - ContactAngle) * cos(ContactAngle + (PI/2.0) );
+        TotalBMomentum.y += Btotal_v * cos(Bangle - ContactAngle) * cos(ContactAngle + (PI/2.0) );
+    } else {
+        TotalAMomentum.x = Aprops.mass * Avel.x + Bprops.mass * Bvel.x;
+        TotalAMomentum.y = Aprops.mass * Avel.y + Bprops.mass * Bvel.y;
+    } //end if Perfect Inelastic or not
 
-    Cannonballs[numA].setVelocity(NewVel);
-    NewVel.y *= -1;
-    NewVel.x *= -1;
-    Cannonballs[numB].setVelocity(NewVel);
+    switch (Global::Physics::CollisionMethod) { //figure out what to do based on the collision method
+    case CollidePerfectInelastic:
+        //The balls collide and stick together
+        //Get the new mass.
+        Aprops.mass += Bprops.mass;
+        //Now we have to calculate the new radius, volume, and area so that drag will reflect the new size
+        //we are of course assuming that density stays the same.
+        Aprops.volume = (Aprops.mass / (double)Global::Physics::uBallDensity);
+        //cbrt = cube root
+        Aprops.radius = cbrt( (double) (3.0*Aprops.volume) / (double) (4.0*PI) );
+        Aprops.area = (double) (2.0 * PI * pow(Aprops.radius, 2) );
+        //Now calculate the new velocity
+        Avel.x = TotalAMomentum.x / Aprops.mass;
+        Avel.y = TotalAMomentum.y / Aprops.mass;
+        //now "kill" cannonball B and update ball A
+        Cannonballs[numB].blnstarted = false;
+        Cannonballs[numA].setPhysicalProps(Aprops);
+        Cannonballs[numA].setVelocity(Avel);
+        break;
+    case CollideInelastic:
+        //uses the same equations as below but some energy is lost.
+        TotalAMomentum.x *= (double)Global::Physics::fMomentumLoss;
+        TotalAMomentum.y *= (double)Global::Physics::fMomentumLoss;
+        TotalBMomentum.x *= (double)Global::Physics::fMomentumLoss;
+        TotalBMomentum.y *= (double)Global::Physics::fMomentumLoss;
 
+    case CollideElastic:
+        //The balls collide and bounce away from each other
 
-    /*LOC Aplace = Cannonballs[numA].getplace();
-    Aplace.x ++;
-    Aplace.y --;
-    Cannonballs[numA].setplace(Aplace);*/
+        //All of the heavy lifting is handled above.
+        Cannonballs[numA].setVelocity(TotalAMomentum);
+        Cannonballs[numB].setVelocity(TotalBMomentum);
+        break;
+    default: //the catch all and CollideNone
+        //Nothing Happens!
+        break;
+    } //end switch collide method
 }
 /**********************************************************************************************************************************************************************/
 BOX boxMaker(LOC place) {

src/tick.cpp

@@ -14,11 +14,11 @@ void clsTick::startTimer(void) {
 /**********************************************************************************************************************************************/
 double clsTick::getTimeDifference(void) {
     double temp_time = (double)(((double)clock() - (double)lngTimerStart) / (double)CLOCKS_PER_SEC);
-    if (Global::blnDebugMode) {
+    /*if (Global::blnDebugMode) {
         FILE* something = fopen("time-log.log","a");
         fprintf(something,"%f\n",temp_time);
         fclose(something);
-    }
+    }*/
     startTimer();
     return temp_time;
 }
@@ -27,7 +27,7 @@ void clsTick::wait(void) {
 	/* Code taken from http://c-for-dummies.com/blog/?p=69 */
 	ulong pause;
 	clock_t now, then;
-	pause = 5 * (CLOCKS_PER_SEC/1000); //pause equals 1 millisecond
+	pause = (CLOCKS_PER_SEC/1000); //pause equals 1 millisecond
     now = then = clock();
 	while ( (ulong)(now - then) < pause) {now = clock();}
 }

src/version.h

@@ -2,7 +2,7 @@
 #define __VERSION_HEADER__
 
 	//Date Version Types
-	#define DEFINED_VER_DATE "15"
+	#define DEFINED_VER_DATE "16"
 	#define DEFINED_VER_MONTH "09"
 	#define DEFINED_VER_YEAR "2015"
 	#define DEFINED_VER_UBUNTU_VERSION_STYLE  "15.09"
@@ -14,17 +14,17 @@
 	//Standard Version Type
 	#define DEFINED_VER_MAJOR  1
 	#define DEFINED_VER_MINOR  1
-	#define DEFINED_VER_BUILD  7
-	#define DEFINED_VER_REVISION  6
+	#define DEFINED_VER_BUILD  8
+	#define DEFINED_VER_REVISION  1
 
 	//Miscellaneous Version Types
-	#define DEFINED_VER_BUILDS_COUNT  160
-	#define DEFINED_VER_RC_FILEVERSION 1,1,7,6
-	#define DEFINED_VER_RC_FILEVERSION_STRING "1, 1, 7, 6\0"
-	#define DEFINED_VER_FULLVERSION_STRING  "1.1.7.6"
+	#define DEFINED_VER_BUILDS_COUNT  0
+	#define DEFINED_VER_RC_FILEVERSION 1,1,8,1
+	#define DEFINED_VER_RC_FILEVERSION_STRING "1, 1, 8, 1\0"
+	#define DEFINED_VER_FULLVERSION_STRING  "1.1.8.1"
 
 	//These values are to keep track of your versioning state, don't modify them.
-	#define DEFINED_VER_BUILD_HISTORY  4
+	#define DEFINED_VER_BUILD_HISTORY  1
 
 
 #endif //__VERSION_HEADER__