Update to v1.2.7-Beta

## [1.2.7-Beta] - 2015-11-18
### Fixed
* Copy Paste Error that caused the pixel texture to remain in memory
* Spelling and grammar mistakes

### Added
* More comments

Author: Patrick Rye

ChangesLog.md

@@ -3,6 +3,15 @@
 All notable changes to this project will be documented here.
 This project adheres to [Semantic Versioning](http://semver.org/)
 
+## [1.2.7-Beta] - 2015-11-18
+### Fixed
+* Copy Paste Error that caused the pixel texture to remain in memory
+* Spelling and grammar mistakes
+
+### Added
+* More comments
+
+
 ## [1.2.6-Beta] - 2015-09-24
 ### Updated
 * Cleanup.bat to include doxygen files (also added wildcard support for some files)

project/SDL-Cannon-Simulation.cbp

@@ -45,6 +45,7 @@
 					<Add option="-Os" />
 					<Add option="-std=c++11" />
 					<Add option="-w" />
+					<Add option="-D__NO_INLINE__" />
 					<Add directory="src/" />
 				</Compiler>
 				<Linker>

project/doxygen/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = Cannon-Simulation
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = v1.2.6-Beta
+PROJECT_NUMBER         = v1.2.7-Beta
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -51,7 +51,7 @@ PROJECT_BRIEF          = "Simulation of Cannonballs hitting each other"
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           = C:/Users/Patrick.Rye/Documents/GitHub/Cannon-Simulation/res/logo.png
+PROJECT_LOGO           = C:/Users/Patrick/Documents/GitHub/SDL-Cannon-Simulation/res/logo.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is

src/cannonball.cpp

@@ -16,7 +16,7 @@ clsCannonball::clsCannonball() {
     ///         * Vel = 0
     /////////////////////////////////////////////////
 
-    //Put some default values in; on the off chance I forget to set them later
+    //Put some default values in; on the off chance I forget to set them later.
     blnDragEnabled = false;
     blnstarted = false;
     deltat = (1.00 / 60.00) ;
@@ -39,7 +39,7 @@ clsCannonball::clsCannonball() {
 /*****************************************************************************/
 void clsCannonball::Drag_calcvalues(void) {
     /////////////////////////////////////////////////
-    /// @brief This will calculate addionational properties of the cannonball based on its radius.
+    /// @brief This will calculate additional properties of the cannonball based on its radius.
     ///        These include:
     ///        * area
     ///        * volume
@@ -114,13 +114,15 @@ void clsCannonball::update(double newdeltat) {
 
     dblLOC.x = dblLOC.x + vel.x * deltat + 0.5 * acc.x * pow(deltat,2);
 	vel.x = (vel.x + acc.x * deltat);
+	//Recoil the ball if it is past an edge
 	if (dblLOC.x <= 0.0 || dblLOC.x >= window.width - Screen_place.w) {
         vel.x *= Global::Physics::fRecoil;
         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);
+	//Recoil the ball if it is past an edge
 	if (dblLOC.y <= Screen_place.h || dblLOC.y >= window.height) {
         vel.y *= Global::Physics::fRecoil;
         dblLOC.y += dblLOC.y <= Screen_place.y ? 1.0 : -1.0;
@@ -150,14 +152,15 @@ void clsCannonball::update(double newdeltat) {
             else {printf("Ball moving too slow; killing it\n");}
         } //end if debug mode
     } //end if should kill
-	show();
+	show(); //show the ball on the screen
 }
 /*****************************************************************************/
 void clsCannonball::setSDLScreen(SDL_Texture* SDLball,
                                  SDL_Texture* SDLpxel,
                                  WINATT SDLwindow, uint newID) {
     /////////////////////////////////////////////////
-    /// @brief This will set certain values for the ball based on the screen. It will also randomly generate a color for the ball.
+    /// @brief This will set certain values for the ball based on the screen.
+    ///        It will also randomly generate a color for the ball.
     ///
     /// @param SDLball = Pointer to clsScreen::ball
     /// @param SDLpxel = Pointer to clsScreen::pixel
@@ -169,7 +172,6 @@ void clsCannonball::setSDLScreen(SDL_Texture* SDLball,
 
     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;
@@ -218,12 +220,12 @@ void clsCannonball::show() {
 void clsCannonball::setValues(double r, LOC init_place,
                               double init_vel, double init_angle) {
     /////////////////////////////////////////////////
-    /// @brief Changes the values of the ball to whatever is entered
+    /// @brief Changes the values of the ball to whatever is entered.
     ///
-    /// @param r = radius of the ball
-    /// @param init_place = its starting location
-    /// @param init_vel = its starting velocity
-    /// @param init_angle = its starting angle (in radians)
+    /// @param r = radius of the ball.
+    /// @param init_place = its starting location.
+    /// @param init_vel = its starting velocity.
+    /// @param init_angle = its starting angle (in radians).
     /// @return void
     ///
     /////////////////////////////////////////////////

src/cannonball.h

@@ -11,7 +11,7 @@
 
 /** This is the max number of points that are recorded and then shown if
     Global::Config.values.blnDrawPathOnScreen is true. I had issues of no more than
-    5 showing up, so 5 is the default value */
+    5 showing up, so 5 is the default value. */
 #define DEFINED_MAXNUMPASTPOINTS 5
 /*****************************************************************************/
 /** Holds X and Y values that are related together, the values are doubles

src/config.cpp

@@ -3,7 +3,8 @@
 #include "version.h"
 /*****************************************************************************/
 /*
-This holds all the functions related to the config file, its loading, making, and holding the values pulled from the config.
+This holds all the functions related to the config file, its loading, making,
+and holding the values pulled from the config.
 */
 /*****************************************************************************/
 clsConfig::clsConfig() {

src/global.h

@@ -7,13 +7,13 @@ class clsConfig;
 /*****************************************************************************/
 //global typedefs
 typedef unsigned char uchar;
-/**< Rename unsigned char to uchar because I'm lazy */
+/**< Rename unsigned char to uchar because I'm lazy. */
 
 typedef unsigned int uint;
-/**< Rename unsigned int to uint because I'm lazy */
+/**< Rename unsigned int to uint because I'm lazy. */
 
 typedef unsigned long ulong;
-/**< Rename unsigned long to ulong because I'm lazy */
+/**< Rename unsigned long to ulong because I'm lazy. */
 
 /*****************************************************************************/
 //Global namespace

src/main.cpp

@@ -12,7 +12,7 @@
 /**< The maximum number of cannonballs allowed. This is because the cannonballs
      are stored in an array; but later versions might allow dynamically allocated number.*/
 
-#define DEFINED_USE_R2_VEL_MODDER
+//j#define DEFINED_USE_R2_VEL_MODDER
 /**< If this is defined, then program will use unrealistic method that will
      increase the velocity of two colliding balls the closer they are together
      it will reduce the number of times that the balls stick together,
@@ -31,13 +31,13 @@ namespace Cannonballs {
 /*****************************************************************************/
 /** The method of the collision (I just wanted to play around with some options.) */
 enum Collisions {
-    CollideElastic = 0, /**< This is normal collision in a perfect would without
-                             friction, they hit and bounce off, no energy is lost */
+    CollideElastic = 0, /**< This is normal collision in a perfect world without
+                             friction, they hit and bounce off, no energy is lost. */
     CollideInelastic, /**< This is the normal way things collide, 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 */
+                                  stick together. */
+    CollideNone /**< No collisions, balls pass through each other. */
 };
 /*****************************************************************************/
 namespace Global {
@@ -94,13 +94,15 @@ namespace Global {
 } //end namespace Global
 /*****************************************************************************/
 int main(int argc, char *argv[]) {
-    /** @brief The main function
-     *
-     * @param argc = Something required by SDL
-     * @param argv = Something required by SDL
-     * @return 0 for successfully ran, or 1 for an error happened.
-     *
-     */
+    /////////////////////////////////////////////////
+    /// @brief The main function
+    ///
+    /// @param argc = Something required by SDL
+    /// @param argv = Something required by SDL
+    /// @return 0 for successfully ran, or 1 for an error happened.
+    ///
+    /////////////////////////////////////////////////
+
 
     Global::Config.Check(); //Load Config file and all its values.
     if (Global::Config.values.blnLogging) { //Open log file to clear it, if it exists
@@ -185,15 +187,16 @@ int main(int argc, char *argv[]) {
 }
 /*****************************************************************************/
 void Cannonballs::addNew(LOC mouseC, LOC mouseO, double HoldTime ) {
-    /** @brief Will add a new cannonball based on the mouse start and mouse end.
-     *         Mass of the ball will vary based on Hold Time
-     *
-     * @param mouseC = Current Mouse Location in X and Y
-     * @param mouseO = Old (start of mouse click) Mouse Location in X and Y
-     * @param HoldTime = Time (in seconds) that the mouse button was held down for
-     * @return void
-     *
-     */
+    /////////////////////////////////////////////////
+    /// @brief Will add a new cannonball based on the mouse start and mouse end.
+    ///        Mass of the ball will vary based on Hold Time
+    ///
+    /// @param mouseC = Current Mouse Location in X and Y
+    /// @param mouseO = Old (start of mouse click) Mouse Location in X and Y
+    /// @param HoldTime = Time (in seconds) that the mouse button was held down for
+    /// @return void
+    ///
+    /////////////////////////////////////////////////
 
     //Get location, vel, and angle
     double fire_v;
@@ -204,7 +207,7 @@ void Cannonballs::addNew(LOC mouseC, LOC mouseO, double HoldTime ) {
     fire_v = -1 * sqrt( pow(mouseC.x - mouseO.x, 2) + pow(mouseC.y - mouseO.y, 2) );
     fire_v /= (double) Global::Equations::fVelocityScalar;
 
-    //if the mouse if pointing straight up or straight down make the angle 90
+    //If the mouse if pointing straight up or straight down make the angle 90
     //Otherwise calculate the angle with atan.
     if (mouseC.x == mouseO.x) {
         angle = (PI / 2.0) * ( (mouseC.y > mouseO.y) ? -1.0 : 1.0 );
@@ -233,10 +236,10 @@ void Cannonballs::addNew(LOC mouseC, LOC mouseO, double HoldTime ) {
 void Cannonballs::checkCollisons(uint j) {
 
     /////////////////////////////////////////////////
-    /// @brief Checks ball number j is colliding with another ball and then do collisions
+    /// @brief Checks ball number j is colliding with another ball and then do collisions.
     ///
-    /// @param  j = the number in the array that ball we are checking is
-    /// @return void (all changes if they are colliding is handled in this function)
+    /// @param  j = the number in the array that ball we are checking is.
+    /// @return void (all changes if they are colliding is handled in this function).
     ///
     /////////////////////////////////////////////////
 

src/screen.cpp

@@ -10,8 +10,8 @@ clsScreen::clsScreen() {
     /// @brief The default constructor for the SDL screen
     ///        it will try start SDL, and create and window and a renderer,
     ///        then try to load the textures it will need, if any of these fail
-    ///        it will set bln_SDL_Started to false and return void, when main in main.cpp
-    ///        checks bln_SDL_Started and ends the entire program will it is false.
+    ///        it will set bln_SDL_Started to false and return void, when main in main.cpp it
+    ///        checks bln_SDL_Started and will end the entire program if it is false.
     ///        If, however, bln_SDL_Started is true it will continue on with the rest of the program.
     /////////////////////////////////////////////////
 
@@ -22,32 +22,41 @@ clsScreen::clsScreen() {
     blnBall = blnPixel = false;
     bln_SDL_started = false;
 
+    //Start SDL
     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+        //SDL returned a non-zero which means there was an error
 		bln_SDL_started = false;
 		error();
 		return;
 	} else {
+	    //SDL started without error
 	    bln_SDL_started = true;
 	    if (Global::blnDebugMode) {printf("SDL init successful\n");}
     }
 
+    //Create the window.
 	window.win = SDL_CreateWindow("Cannon Simulation",100,100,
                                window.width, window.height, SDL_WINDOW_SHOWN);
 
+    //Check if the window was created properly
 	if (window.win == nullptr) {
+        //Window was not created
         printf("SDL Failed to create window.\n");
         cleanup();
         error();
 		bln_SDL_started = false;
 		return;
 	} else {
+	    //Window was created
 	    blnWindow = true;
 	    if (Global::blnDebugMode) {printf("Window creation successful\n");}
 	}
 
+    //Try to create the renderer
 	window.ren = SDL_CreateRenderer(window.win, -1,
                     SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
 
+    //Check if renderer was created.
 	if (window.ren == nullptr) {
         printf("SDL Failed to create renderer.\n");
         cleanup();
@@ -59,9 +68,10 @@ clsScreen::clsScreen() {
 	    if (Global::blnDebugMode) {printf("Renderer creation successful\n");}
     }
 
-    //Set the background color of the render to black
+    //Set the background color of the renderer to black
     SDL_SetRenderDrawColor(window.ren, 0x00, 0x00, 0x00, 0xFF );
 
+    //Load the ball texture
     ball = loadIMG("ball");
     if (bln_SDL_started == false) {return;}
     else {
@@ -71,14 +81,15 @@ clsScreen::clsScreen() {
         SDL_SetTextureBlendMode(ball, SDL_BLENDMODE_BLEND );
     }
 
+    //Load the pixel texture
     pixel = loadIMG("pixel");
     if (bln_SDL_started == false) {return;}
     else {
         blnPixel = true;
         if (Global::blnDebugMode) {printf("Pixel loading successful\n");}
     }
 
-}
+} //end of constructor
 /*****************************************************************************/
 clsScreen::~clsScreen() {
     /////////////////////////////////////////////////
@@ -129,10 +140,11 @@ void clsScreen::cleanup() {
         blnBall = false;
         if (Global::blnDebugMode) {printf("Ball texture destroyed\n");}
     }
-    if (blnBall) {
+
+    if (blnPixel) {
         SDL_DestroyTexture(pixel);
         blnPixel = false;
-        if (Global::blnDebugMode) {printf("Ball texture destroyed\n");}
+        if (Global::blnDebugMode) {printf("Pixel texture destroyed\n");}
     }
 	if (blnRenderer) {
         SDL_DestroyRenderer(window.ren);
@@ -160,11 +172,13 @@ SDL_Texture* clsScreen::loadIMG(std::string filename) {
     /////////////////////////////////////////////////
     /// @brief Will load a specified image into a texture.
     ///        It will first load it from the XPM array that it is embedded as into a surface,
-    ///        then will will convert the surface into a texture, if that fails it will set bln_SDL_started to false
+    ///        then will will convert the surface into a texture, if that fails
+    ///        it will set bln_SDL_started to false
     ///        and return nullptr, otherwise returns texture.
     ///
-    /// @param filename = The texture to load (currently only supports "ball" or "pixel" as those are the only two textures needed)
-    /// @return Pointer to the texture in memory
+    /// @param filename = The texture to load (currently only supports "ball"
+    ///                   or "pixel" as those are the only two textures needed).
+    /// @return Pointer to the texture in memory.
     /////////////////////////////////////////////////
 
     SDL_Surface* temp;