Update to v1.2.0-beta

17 September 2015
   Released version 1.2.0-Beta

     Change log:

-Fixed: The Collision equations a bit more
  -Added: Cannonball now
holds its own box
  -Changed: Attempted to make the code more efficient

  -Added: Keyboard Press events, (Q/ESC to quit, K to kill all balls,
and R to stop all motion)
  -Updated: Readme
  -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: fMomentumLoss
name to fCoefficientRestitution to be named after its real life counter
part
  -Added: Friction between the ball and floor / wall

Author: Patrick Rye

ChangesLog.txt

@@ -1,3 +1,20 @@
+17 September 2015
+   Released version 1.2.0-Beta
+
+     Change log:
+        -Fixed: The Collision equations a bit more
+		-Added: Cannonball now holds its own box
+		-Changed: Attempted to make the code more efficient 
+		-Added: Keyboard Press events, (Q/ESC to quit, K to kill all balls, and R to stop all motion)
+		-Updated: Readme
+		-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: fMomentumLoss name to fCoefficientRestitution to be named after its real life counter part
+		-Added: Friction between the ball and floor / wall
+		
+
 16 September 2015
    Released version 1.1.9-Beta
 

README.md

@@ -28,3 +28,35 @@ FolderName\SDL2_image.dll
 ```
 
 Let me know if I am missing a dependences that I might have forgotten about due to my own system set up.
+
+# Using the Program
+
+The first time you run the program a Config.ini will be created it should look something like below:
+
+```
+Config File for the Cannon.exe
+1.2.0.25-b
+Screen Width: 640
+Screen Height: 480
+Log Ball's path: 0
+Enable Drag Mode (experimental): 0
+```
+
+You can use this to change things like the screen height and width, and other stuff.
+
+"Log Ball's Path" (if enabled with a 1 instead of 0), will cause a a file called "logfile.log", which will contain the placement of every ball on every update (it gets quite big as you can guess).
+
+"Enable drag Mode" (if enabled with a 1 instead of 0), will cause the cannonballs to be effected by drag. It is listed as experimental because I based the equations used off of several things I found 
+online and I cannot verify how accuate it is.
+
+Once you start the program you will be greeted with a beautiful white screen. To create a new cannonball you click (and hold down the button) 
+you can now move your move around to change the angle that the new cannonball will be fired at; as well as the longer the line the faster it will go. 
+When you are happy with the angle and speed simply release the mouse button and it will be created at the point where you clicked the mouse button down.
+
+You can also press the following keys to yield effects
+
+```
+K = All Balls will be "killed".
+R = All motion will be stopped.
+Q / ESC = Program will exit.
+```

project/SDL-Cannon-Simulation.cbp

@@ -144,7 +144,7 @@
 		<Unit filename="../src/version.h" />
 		<Extensions>
 			<AutoVersioning>
-				<Scheme minor_max="10" build_max="999" rev_max="999" rev_rand_max="1" build_times_to_increment_minor="1000" />
+				<Scheme minor_max="10" build_max="10" rev_max="999" rev_rand_max="1" build_times_to_increment_minor="1000" />
 				<Settings autoincrement="1" date_declarations="1" use_define="1" update_manifest="0" do_auto_increment="1" ask_to_increment="1" language="C" svn="0" svn_directory="" header_path="..\src\version.h" />
 				<Changes_Log show_changes_editor="1" app_title="Released version %M.%m.%b-%T" changeslog_path="..\ChangesLog.txt" />
 				<Code header_guard="__VERSION_HEADER__" namespace="Version" prefix="DEFINED_VER" />

src/cannonball.cpp

@@ -40,52 +40,78 @@ void clsCannonball::Drag_calcvalues(void) {
 }
 /**********************************************************************************************************************************************/
 void clsCannonball::Drag_updateacc(void) {
-	double flow_velocity = sqrt(pow(vel.x,2) + pow(vel.y,2));
-	double Drag_Force = (double) (0.5 * Global::Physics::fDensityAir * flow_velocity * Global::Physics::fDragCofficient * props.area);
-	double Drag_Acc = (double) (Drag_Force / props.mass);
-
-	double angle = atan(vel.y / vel.x);
-
-	acc.x -= Drag_Acc * cos (angle);
-	if (vel.y < 0) {acc.y += Drag_Acc * sin (angle);}
-	else {acc.y -= Drag_Acc * sin (angle);}
+    acc.x = 0.0;
+    acc.y = Global::Physics::fGravity;
+    if (vel.x != 0.0 && vel.y != 0.0 && props.mass != 0.0) {
+        double flow_velocity = sqrt(pow(vel.x,2) + pow(vel.y,2));
+        double Drag_Force = (double) (0.5 * Global::Physics::fDensityAir * flow_velocity * Global::Physics::fDragCofficient * props.area);
+        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;}
+
+        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;
+
+        //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;}
+        }
+
+        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;}
+        }
+    } //end if things don't equal 0
 }
 /**********************************************************************************************************************************************/
 void clsCannonball::update(double newdeltat) {
     deltat = newdeltat;
-    SDL_Rect dst;
-    SDL_QueryTexture(ball,NULL,NULL, &dst.w, &dst.h);
 
     if (blnDragEnabled) {Drag_updateacc();}
 
     dblLOC.x = dblLOC.x + vel.x * deltat + 0.5 * acc.x * pow(deltat,2);
 	vel.x = (vel.x + acc.x * deltat);
-	if (dblLOC.x <= 0.0 || dblLOC.x >= window.width - dst.w) {
+	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--;}
     } //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 <= dst.h || dblLOC.y >= window.height) {
+	if (dblLOC.y <= Screen_place.h || dblLOC.y >= window.height) {
         vel.y *= Global::Physics::fRecoil;
-        if (dblLOC.y <= dst.h) {dblLOC.y++;}
+        if (dblLOC.y <= Screen_place.h) {dblLOC.y++;}
         else {dblLOC.y--;}
     }//end if hitting y edges
 
-    if (dblLOC.x < 0.0) {place.x = 0;}
+    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;}
+    if (dblLOC.y < 0.0) {place.y = 0; dblLOC.y = 0;}
     else {place.y = round(dblLOC.y);}
 
-	//if (Global::blnDebugMode) {printf("Ball updated, new position (%f, %f)\n",dblLOC.x,dblLOC.y);}
 	if (Global::Config.values.blnLogging) {
         FILE* logfile = fopen("logfile.log","a");
         fprintf(logfile,"Ball %3u \t (%.3f, %.3f)\n",ballID, dblLOC.x,dblLOC.y);
         fclose(logfile);
 	}
 
+	//Update the collision box for the new location
+	CollisionBox.left = place.x;
+	CollisionBox.top = window.height - place.y;
+	CollisionBox.right = CollisionBox.left + Screen_place.w;
+	CollisionBox.bottom = CollisionBox.top + Screen_place.h;
+
     double total_v;
     total_v = sqrt( pow(vel.x,2) + pow(vel.y,2) );
     if (total_v < Global::Physics::fMinVelocity || isnan(total_v) ) {
@@ -100,22 +126,24 @@ void clsCannonball::update(double newdeltat) {
 /**********************************************************************************************************************************************/
 void clsCannonball::setSDLScreen(SDL_Texture* SDLball, WINATT SDLwindow) {
     ball = SDLball;
+    SDL_QueryTexture(ball,NULL,NULL, &Screen_place.w, &Screen_place.h);
     window = SDLwindow;
 }
 /**********************************************************************************************************************************************/
 void clsCannonball::show() {
-    SDL_Rect dst;
-    SDL_QueryTexture(ball,NULL,NULL, &dst.w, &dst.h);
-    dst.x = place.x;
-    dst.y = window.height - place.y;
+    Screen_place.x = place.x;
+    Screen_place.y = window.height - place.y;
     //Place the ball
-    SDL_RenderCopy(window.ren,ball,NULL,&dst);
+    SDL_RenderCopy(window.ren,ball,NULL,&Screen_place);
 }
 /**********************************************************************************************************************************************/
 void clsCannonball::setValues(double r, LOC init_place, double init_vel, double init_angle, uint ID) {
     props.radius = r; //in meters
     props.density = Global::Physics::uBallDensity; //density of steel in kg/m^3
 
+    acc.x = 0.00;
+    acc.y = Global::Physics::fGravity;
+
     place = init_place;
     dblLOC.x = (double) place.x;
     dblLOC.y = (double) place.y;
@@ -156,3 +184,7 @@ void clsCannonball::setPhysicalProps(PP newprops) {
     props = newprops;
 }
 /**********************************************************************************************************************************************/
+BOX clsCannonball::getBOX() {
+    return CollisionBox;
+}
+/**********************************************************************************************************************************************/

src/cannonball.h

@@ -23,8 +23,17 @@ struct stcPhysicalProperties {
     double volume;
     double density;
 };
+
+struct stcBox {
+    uint left;
+    uint right;
+    uint top;
+    uint bottom;
+};
+
 typedef struct stcDoubleValues dblXY;
 typedef struct stcPhysicalProperties PP;
+typedef struct stcBox BOX;
 /**********************************************************************************************************************************************/
 class clsCannonball {
     public:
@@ -40,6 +49,7 @@ class clsCannonball {
         void setVelocity(dblXY);
         PP getPhysicalProps(void);
         void setPhysicalProps(PP);
+        BOX getBOX(void);
 
         bool blnstarted;
     private:
@@ -49,6 +59,9 @@ class clsCannonball {
         SDL_Texture* ball;
         WINATT window;
 
+        BOX CollisionBox;
+        SDL_Rect Screen_place;
+
         LOC place;
         dblXY vel;
         dblXY dblLOC;

src/global.h

@@ -16,11 +16,12 @@ namespace Global {
         extern const uint uBallDensity;
         extern const float fGravity;
         extern const float fDragCofficient;
+        extern const float fKineticFriction;
         extern const float fDensityAir;
         extern const float fRecoil;
         extern const float fVelocityScalar;
         extern const float fMinVelocity;
-        extern const float fMomentumLoss;
+        extern const float fCoefficientRestitution;
         extern const uchar CollisionMethod;
     }
 }