Update to v1.2.4-beta

21 September 2015
   Released version 1.2.4-Beta

     Change log:

-Added: Balls are different colors
  -Changed: Ball ID is now set in
Screen set
  -Changed: Unrealistic method added in 1.1.9-Beta can be
toggled easier (with define)
      Its funny to enable and watch even if
it doesn't do what it is supposed to

Author: Patrick Rye

ChangesLog.txt

@@ -1,3 +1,12 @@
+21 September 2015
+   Released version 1.2.4-Beta
+
+     Change log:
+        -Added: Balls are different colors
+		-Changed: Ball ID is now set in Screen set
+		-Changed: Unrealistic method added in 1.1.9-Beta can be toggled easier (with define)
+				  Its funny to enable and watch even if it doesn't do what it is supposed to
+
 21 September 2015
    Released version 1.2.3-Beta
 

README.md

@@ -35,19 +35,22 @@ The first time you run the program a Config.ini will be created it should look s
 
 ```
 Config File for the Cannon.exe
-1.2.0.25-b
+1.2.4.60-b
 Screen Width: 640
 Screen Height: 480
 Log Ball's path: 0
 Enable Drag Mode (experimental): 0
+Draw Ball path on screen: 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.
+online and I cannot verify how accurate it is.
+
+"Draw Ball path on Screen" (if enabled with a 1 instead of 0), will cause small pixels to trail after each ball.
 
 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. 

src/cannonball.cpp

@@ -111,7 +111,14 @@ void clsCannonball::update(double newdeltat) {
 	show();
 }
 /**********************************************************************************************************************************************/
-void clsCannonball::setSDLScreen(SDL_Texture* SDLball, SDL_Texture* SDLpxel, WINATT SDLwindow) {
+void clsCannonball::setSDLScreen(SDL_Texture* SDLball, SDL_Texture* SDLpxel, WINATT SDLwindow, uint newID) {
+    ballID = newID;
+    //set the color of the ball
+    //Set some ID's to have specific colors, but otherwise randomize them
+    Color.Red = rand() % 255;
+    Color.Green = rand() % 255;
+    Color.Blue = rand() % 255;
+
     ball = SDLball;
     pixel = SDLpxel;
     SDL_QueryTexture(ball,NULL,NULL, &Screen_place.w, &Screen_place.h);
@@ -133,12 +140,18 @@ void clsCannonball::show() {
 
     //set the ball alpha
     SDL_SetTextureAlphaMod(ball, alpha);
+    SDL_SetTextureColorMod(ball, Color.Red, Color.Green, Color.Blue);
 
     //Place the ball
     SDL_RenderCopy(window.ren,ball,NULL,&Screen_place);
+
+    //reset ball Alpha and color so it doesn't effect the next ball
+    SDL_SetTextureAlphaMod(ball, 0xFF);
+    SDL_SetTextureColorMod(ball, 0xFF, 0xFF, 0xFF);
+
 }
 /**********************************************************************************************************************************************/
-void clsCannonball::setValues(double r, LOC init_place, double init_vel, double init_angle, uint ID) {
+void clsCannonball::setValues(double r, LOC init_place, double init_vel, double init_angle) {
     props.radius = r; //in meters
 
     acc.x = 0.00;
@@ -150,8 +163,6 @@ void clsCannonball::setValues(double r, LOC init_place, double init_vel, double
 
     vel.x = (double)(init_vel) * (cos(init_angle));
 	vel.y = (double)(init_vel) * (sin(init_angle));
-
-	ballID = ID;
 	blnstarted = true;
 
     Drag_calcvalues();
@@ -193,6 +204,7 @@ void clsCannonball::drawPath(LOC newplace) {
 
     //If there have been enough updates since the last time the path was updated,
     //then update the path array otherwise inc updates
+    SDL_SetTextureColorMod(pixel, Color.Red, Color.Green, Color.Blue);
     if ( UpdatesSinceLast >= 25 ) {
         UpdatesSinceLast = 0;
         //First move all the old locations down one spot in the array
@@ -208,5 +220,6 @@ void clsCannonball::drawPath(LOC newplace) {
         dst.x = (uint)(path[i].x + Screen_place.w / 2);
         SDL_RenderCopy(window.ren, pixel, NULL, &dst);
     } //end for
+    SDL_SetTextureColorMod(pixel, 0xFF, 0xFF, 0xFF);
 }
 /**********************************************************************************************************************************************/

src/cannonball.h

@@ -5,6 +5,7 @@
 #include <math.h>
 #include <cstdio>
 #include <cstdlib>
+//#include <time.h>
 #include "config.h"
 #include "global.h"
 #include "screen.h"
@@ -32,20 +33,27 @@ struct stcBox {
     uint bottom;
 };
 
+struct stcColor {
+    Uint8 Red;
+    Uint8 Green;
+    Uint8 Blue;
+};
+
 typedef struct stcDoubleValues dblXY;
 typedef struct stcPhysicalProperties PP;
 typedef struct stcBox BOX;
+typedef struct stcColor clr;
 /**********************************************************************************************************************************************/
 class clsCannonball {
     public:
         /** Default constructor */
         clsCannonball();
-        void setValues(double, LOC, double, double, uint);
+        void setValues(double, LOC, double, double);
         LOC getplace(void);
         void setplace(LOC);
 
         void update(double);
-        void setSDLScreen(SDL_Texture*, SDL_Texture*, WINATT);
+        void setSDLScreen(SDL_Texture*, SDL_Texture*, WINATT, uint);
         dblXY getVelocity(void);
         void setVelocity(dblXY);
         PP getPhysicalProps(void);
@@ -56,7 +64,7 @@ class clsCannonball {
     private:
         uint ballID;
         bool blnDragEnabled;
-
+        clr Color;
         SDL_Texture* ball;
         SDL_Texture* pixel;
         WINATT window;

src/main.cpp

@@ -1,5 +1,6 @@
 /* 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#5#): Collision Method can be set in Config */
+/* TODO (GamerMan7799#9#): Allow setting of same Physics Values in Config */
 /**********************************************************************************************************************************************************************/
 #include <SDL2/SDL.h>
 #include <cstdio>
@@ -41,7 +42,7 @@ namespace Global {
         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 uchar CollisionMethod = CollideInelastic;
+        const uchar CollisionMethod = CollideInelastic; //The collision method to use (see above)
     }
 
     namespace Equations { //Holds Values for different equations that are not physics related
@@ -55,6 +56,8 @@ namespace Global {
 /**********************************************************************************************************************************************************************/
 //This is the maximum number of cannonballs which can be "alive" at a time
 #define DEFINED_CANNONBALL_LIMIT 20
+//IF this is not commented out then program will use unrealistic method that will increase velocity the closer they are together
+//#define DEFINED_USE_R2_VEL_MODDER
 /**********************************************************************************************************************************************************************/
 clsCannonball Cannonballs[DEFINED_CANNONBALL_LIMIT];
 /**********************************************************************************************************************************************************************/
@@ -72,7 +75,7 @@ int main(int argc, char *argv[]) {
 
     //Since all the Cannonballs will share the same SDL screen stuff place them all together
     for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) {
-        Cannonballs[i].setSDLScreen( CannonWindow.getBallTexture(), CannonWindow.getPixelTexture(), CannonWindow.getWindow() );
+        Cannonballs[i].setSDLScreen( CannonWindow.getBallTexture(), CannonWindow.getPixelTexture(), CannonWindow.getWindow(), i );
     }
 
     bool quit = false;
@@ -160,7 +163,7 @@ void addNewCannonball(LOC mouseC, LOC mouseO, double HoldTime ) {
     //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(radius, mouseO, fire_v, angle, i);
+            Cannonballs[i].setValues(radius, mouseO, fire_v, angle);
             return;
         } //end if not started
     } //end for cannonballs.
@@ -199,9 +202,10 @@ void doCollision(uint numA, uint numB) {
     Aprops = Cannonballs[numA].getPhysicalProps();
     Bprops = Cannonballs[numB].getPhysicalProps();
 
+#ifdef DEFINED_USE_R2_VEL_MODDER
     //This part here has no actual basis on real life,
     //it is just my attempt at preventing the cannonballs from sticking together
-    /*LOC CenterA, CenterB, DeltaCenters;
+    LOC CenterA, CenterB, DeltaCenters;
     double VelModder;
     CenterA = Cannonballs[numA].getplace();
     CenterB = Cannonballs[numB].getplace();
@@ -216,8 +220,9 @@ void doCollision(uint numA, uint numB) {
     Avel.x *= (double) VelModder;
     Avel.y *= (double) VelModder;
     Bvel.x *= (double) VelModder;
-    Bvel.y *= (double) VelModder;*/
+    Bvel.y *= (double) VelModder;
     //End of non real stuff
+#endif
 
     double Aangle, Bangle, ContactAngle;
     double Atotal_v, Btotal_v;

src/version.h

@@ -14,14 +14,14 @@
 	//Standard Version Type
 	#define DEFINED_VER_MAJOR  1
 	#define DEFINED_VER_MINOR  2
-	#define DEFINED_VER_BUILD  3
-	#define DEFINED_VER_REVISION  60
+	#define DEFINED_VER_BUILD  4
+	#define DEFINED_VER_REVISION  61
 
 	//Miscellaneous Version Types
-	#define DEFINED_VER_BUILDS_COUNT  20
-	#define DEFINED_VER_RC_FILEVERSION 1,2,3,60
-	#define DEFINED_VER_RC_FILEVERSION_STRING "1, 2, 3, 60\0"
-	#define DEFINED_VER_FULLVERSION_STRING  "1.2.3.60"
+	#define DEFINED_VER_BUILDS_COUNT  25
+	#define DEFINED_VER_RC_FILEVERSION 1,2,4,61
+	#define DEFINED_VER_RC_FILEVERSION_STRING "1, 2, 4, 61\0"
+	#define DEFINED_VER_FULLVERSION_STRING  "1.2.4.61"
 
 	//These values are to keep track of your versioning state, don't modify them.
 	#define DEFINED_VER_BUILD_HISTORY  1