Update to v1.4.1-rc.1

## [1.4.1-rc.1] - 2020.05.29
### Added
* Pause symbol for when simulation is paused (Issue #10)

### Fixed
* Defined macros not working correctly since I moved certain functions to core.cpp

### Changed
* Modified the check overlap function

Author: CoderMonad

docs/ChangesLog.md

@@ -3,18 +3,21 @@
 All notable changes to this project will be documented here.
 This project adheres to [Semantic Versioning](http://semver.org/)
 
-## [1.4.1-beta.3] - Unreleased
+## [1.4.1-rc.1] - Unreleased
 ### Added
 * Math function specifically to deal with vector math.
+* Pause symbol for when simulation is paused (Issue #10)
 
 ### Fixed
 * Spelling mistakes
 * Various Code mistakes
 * Drag tool not un-pausing correctly
+* Defined macros not working correctly since I moved certain functions to core.cpp
 
 ### Changed
 * Updated Doxygen file
 * Info tool now displays if ball is paused
+* Modified the check overlap function
 
 ## [1.4.0-R] - 2018-03-27
 ### Added

src/core.cpp

@@ -58,9 +58,7 @@ void cannonballs::addNew(LOC mouseC, LOC mouseO, double HoldTime ) {
   intCannonBallNum++;
   clsCannonball tempBall;
   tempBall.setValues(radius, mouseO, fire_v, angle, intCannonBallNum);
-  if (intCannonBallNum > 1) {
-    if(balls[0].isPaused()) { tempBall.togglePause(); }
-  }
+  if (global::blnPaused) { tempBall.togglePause(); }
   balls.push_back(tempBall);
 
   return;
@@ -77,6 +75,7 @@ void cannonballs::checkCollisons(uint j) {
   /////////////////////////////////////////////////
 
   BOX A, B;
+  dblXY ball_a_loc;
   dblXY ball_b_loc;
   A = balls[j].getBOX();
   if (balls[j].blncheckphysics_) {
@@ -85,14 +84,31 @@ void cannonballs::checkCollisons(uint j) {
         B = balls[i].getBOX();
         if ( checkOverlap(A, B) ) {
           doCollide(j, i);
-          ball_b_loc = balls[i].getdbLOC();
-          /** @todo (GamerMan7799#9#): This might work for stopping the balls from overlapping, just need to add a check on which way they are colliding */
-           /*do {
-            ball_b_loc.x++;
-            ball_b_loc.y++;
+          /** @todo (GamerMan7799#3#): This might work for stopping the balls from overlapping, just need to add a check on which way they are colliding */
+#if DEFINED_PUSH_BALLS_OUT_OF_OVERLAP == 1
+           ball_a_loc = balls[j].getdbLOC();
+           ball_b_loc = balls[i].getdbLOC();
+           do {
+              if (A.right <= B.right && A.right >= B.left) {
+                ball_a_loc.x--;
+                ball_b_loc.x++;
+              } else if (A.left >= B.left && A.left <= B.right) {
+                ball_a_loc.x++;
+                ball_b_loc.x--;
+              }
+              if (A.top >= B.top && A.top <= B.bottom) {
+                ball_a_loc.y++;
+                ball_b_loc.y--;
+              } else if (A.bottom >= B.top && A.bottom <= B.bottom) {
+                ball_a_loc.y--;
+                ball_b_loc.y++;
+              }
             balls[i].setdbLOC(ball_b_loc);
+            balls[j].setdbLOC(ball_a_loc);
+            A = balls[j].getBOX();
             B = balls[i].getBOX();
-          } while (checkOverlap(A,B)); */
+          } while (checkOverlap(A,B));
+#endif
           balls[i].blncheckphysics_ = false;
           balls[j].blncheckphysics_ = false;
         } // end if overlap
@@ -111,12 +127,24 @@ bool cannonballs::checkOverlap(BOX A, BOX B) {
   ///
   /////////////////////////////////////////////////
 
-  if( A.right < B.left ){ return false; }
+  /** @todo (GamerMan7799#9#): Improve the overlap check to allow pixel-by-pixel detection */
+
+  if (A.right <= B.right && A.right >= B.left) {
+      if (A.top >= B.top && A.top <= B.bottom) { return true; }
+      else if (A.bottom >= B.top && A.bottom <= B.bottom) { return true; }
+      else { return false; }
+  } else if (A.left >= B.left && A.left <= B.right) {
+      if (A.top >= B.top && A.top <= B.bottom) { return true; }
+      else if (A.bottom >= B.top && A.bottom <= B.bottom) { return true; }
+      else { return false; }
+  } else { return false; }
+
+  /*if( A.right < B.left ){ return false; }
   if( A.left > B.right ){ return false; }
   if( A.bottom < B.top ){ return false; }
   if( A.top > B.bottom ){ return false; }
 
-  return true;
+  return true;*/
 }
 /*****************************************************************************/
 void cannonballs::doCollide(uint numA, uint numB) {
@@ -408,6 +436,7 @@ char core::handleEvent(SDL_Event* e ) {
       return 0;
     case SDLK_p:
       //"pauses" the simulation by preventing ball from updating
+      global::blnPaused = !(global::blnPaused);
       for (int i = 0; i < cannonballs::balls.size(); ++i)
         { cannonballs::balls[i].togglePause(); }
       return 0;
@@ -544,23 +573,11 @@ void core::doDragTool(SDL_Event* e) {
   }
 
   //if(global::blnDebugMode) { printf("Tool Drag event\n"); }
-  if ( holding && !(cannonballs::balls[ball_num].isPaused()) ) {
+  if ( holding && !(cannonballs::balls[ball_num].isPaused()) && !(global::blnPaused) ) {
     cannonballs::balls[ball_num].togglePause();
-  } else if ( !(holding) ) {
-    // check if the ball is the first or last
-    if (&cannonballs::balls[ball_num] == &cannonballs::balls.front()) {
-      if (!(cannonballs::balls.back().isPaused()) &&
-          cannonballs::balls[ball_num].isPaused()) {
-            cannonballs::balls[ball_num].togglePause();
-            ball_num = -1;
-          }
-    } else {
-      if (!(cannonballs::balls.front().isPaused()) &&
-          cannonballs::balls[ball_num].isPaused()) {
-            cannonballs::balls[ball_num].togglePause();
-            ball_num = -1;
-          }
-    }
+  } else if ( !(holding) && !(global::blnPaused) ) {
+    cannonballs::balls[ball_num].togglePause();
+    ball_num = -1;
   }
 }
 /*****************************************************************************/

src/global.h

@@ -9,6 +9,21 @@
 ///        Global namespace. See Main.cpp for more details
 /////////////////////////////////////////////////
 /*****************************************************************************/
+#define DEFINED_USE_R2_VEL_MODDER 0
+/**< 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,
+     but also causes them to get unrealistically high velocities. */
+/*****************************************************************************/
+#define DEFINED_COLLISION_NORMAL_FORCE 0
+/**< If this is defined, then program will use apply a normal force to any
+     colliding balls. The forces are along the same direction as the velocities
+     are. It doesn't make sense in the real world. */
+/*****************************************************************************/
+#define DEFINED_PUSH_BALLS_OUT_OF_OVERLAP 1
+/**< This will turn on a method that will attempt to move the balls until they
+     are no longer overlapping when detecting collision. */
+/*****************************************************************************/
 class clsConfig;
 /*****************************************************************************/
 //global typedefs
@@ -31,6 +46,7 @@ namespace cannonballs {
 namespace global {
   extern const bool blnDebugMode;
   extern clsConfig config;
+  extern bool blnPaused;
   namespace physics {
   /////////////////////////////////////////////////
   /// @defgroup ChangeablePhysics Defined Physics values
@@ -88,7 +104,8 @@ enum Tools {
   ToolDrop,     /**< Drops a ball without velocity. */
   ToolDele,     /**< Tool to delete selected ball. */
   ToolDrag,     /**< Tool that allows ball to be dragged around. */
-  ToolInfo      /**< Tool that writes information about the selected ball to screen */
+  ToolInfo,     /**< Tool that writes information about the selected ball to screen */
+  ToolPause     /**< Not really a tool, but the pause symbol */
 };
 /*****************************************************************************/
 #endif // __GLOBAL_H_INCLUDED__

src/image_tools.xpm

@@ -1,6 +1,6 @@
 /* XPM */
 static char * image_tools_xpm[] = {
-"24 144 2 1",
+"24 168 2 1",
 " 	c None",
 ".	c #FFFFFF",
 "                        ",
@@ -146,4 +146,28 @@ static char * image_tools_xpm[] = {
 "    ................    ",
 "      .............     ",
 "       ..........       ",
-"          ....          "};
+"          ....          ",
+"                        ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+" ........      ........ ",
+"                        "};

src/main.cpp

@@ -4,8 +4,8 @@
 /// @brief      Holds all the main functions.
 /// @author     GamerMan7799
 /// @author     xPUREx
-/// @version    1.4.0-R
-/// @date       2018
+/// @version    1.4.1-rc.1
+/// @date       2015-2020
 /// @copyright  Public Domain Unlicense.
 /////////////////////////////////////////////////
 /*****************************************************************************/
@@ -16,17 +16,6 @@
 /** @todo (GamerMan7799#8#): Allow setting of some Physics Values in Config */
 /** @todo (GamerMan7799#8#): Set Max/Min values for mass? */
 /*****************************************************************************/
-#define DEFINED_USE_R2_VEL_MODDER 0
-/**< 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,
-     but also causes them to get unrealistically high velocities. */
-/*****************************************************************************/
-#define DEFINED_COLLISION_NORMAL_FORCE 0
-/**< If this is defined, then program will use apply a normal force to any
-     colliding balls. The forces are along the same direction as the velocities
-     are. It doesn't make sense in the real world. */
-/*****************************************************************************/
 #include "version.h"
 #include "core.h"
 /*****************************************************************************/
@@ -40,6 +29,7 @@ namespace global {
 #endif
 
   clsConfig config;
+  bool blnPaused = false;
 
   /** Holds Values that are related the the physics of the world,
       these are all based on real numbers */

src/screen.cpp

@@ -330,6 +330,8 @@ void clsScreen::setClips() {
    *     +-----+
    *     |(0,5)|
    *     +-----+
+   *     |(0,6)|
+   *     +-----+
    */
 
    int pic_size = 24;
@@ -340,6 +342,7 @@ void clsScreen::setClips() {
    screen::screenatt.toolclips[ToolDele] = {0 * pic_size, 3 * pic_size, pic_size, pic_size};
    screen::screenatt.toolclips[ToolDrag] = {0 * pic_size, 4 * pic_size, pic_size, pic_size};
    screen::screenatt.toolclips[ToolInfo] = {0 * pic_size, 5 * pic_size, pic_size, pic_size};
+   screen::screenatt.toolclips[ToolPause] = {0 * pic_size, 6 * pic_size, pic_size, pic_size};
 
 }
 /*****************************************************************************/

src/screen.h

@@ -28,7 +28,7 @@ struct stcWinAtt {
   SDL_Texture *pixel; /**< The pixel texture, used to draw lines */
   SDL_Texture *toolbox; /**< Toolbox frame texture. */
   SDL_Texture *tools; /**< Textures for the tools in the toolbox. */
-  SDL_Rect toolclips[6]; /**< Clips for the different tools. */
+  SDL_Rect toolclips[7]; /**< Clips for the different tools. */
 };
 /*****************************************************************************/
 typedef struct stcWinAtt WINATT;

src/toolbar.cpp

@@ -22,6 +22,10 @@ void clsToolbar::show() {
 
   // Make SDL rect just for the tool picture inside the frame
   SDL_Rect tool_pic_box = {position_.x+2,position_.y+2,24,24};
+  SDL_Rect pause_location = {screen::screenatt.width-24,2,24,24};
+
+  pause_location.x + 28;
+
 
   if(show_toolbox_) { // only show if enabled
     SDL_RenderCopy(screen::screenatt.ren,screen::screenatt.toolbox,
@@ -31,6 +35,10 @@ void clsToolbar::show() {
     SDL_RenderCopy(screen::screenatt.ren,screen::screenatt.tools,
                    &screen::screenatt.toolclips[selected_tool_], &tool_pic_box);
 
+    if (global::blnPaused) {
+      SDL_RenderCopy(screen::screenatt.ren,screen::screenatt.tools,
+                     &screen::screenatt.toolclips[ToolPause], &pause_location);
+    }
   }
 }
 /*****************************************************************************/

src/version.h

@@ -15,7 +15,7 @@
 /*****************************************************************************/
 //Date Version Types
 /** The day of the last build of the program, currently not used. */
-#define DEFINED_VER_DATE "28"
+#define DEFINED_VER_DATE "29"
 
 /** The month of the last build of the program, currently not used. */
 #define DEFINED_VER_MONTH "05"
@@ -37,13 +37,13 @@
 /*****************************************************************************/
 /** The version number in a format used by Boilerplate.rc, It is in the following format
     [MAJOR].[MINOR].[PATCH].[BUILDNUMBER] */
-#define DEFINED_VER_RC_FILEVERSION 1,4,1,3
+#define DEFINED_VER_RC_FILEVERSION 1,4,1,4
 
 /** Is the same as DEFINED_VER_RC_FILEVERSION but is a null terminated string */
-#define DEFINED_VER_RC_FILEVERSION_STRING "1, 4, 1, 3\0"
+#define DEFINED_VER_RC_FILEVERSION_STRING "1, 4, 1, 4\0"
 
 /** A more specific string of the file version */
-#define DEFINED_VER_FULLVERSION_STRING  "1.4.1-beta.3\0"
+#define DEFINED_VER_FULLVERSION_STRING  "1.4.1-rc.1\0"
 
 //Software Status
 /**
@@ -55,10 +55,10 @@ Software Status can be the following:
 | Beta | b | This version will compile and / or run but does not work as expected (or crashes often). |
 | Alpha | a | This version does not work at all; it usually won't compile at all or crashes more times than it works; best not to use versions in this state. |
 */
-#define DEFINED_VER_STATUS 	"Beta"
+#define DEFINED_VER_STATUS 	"Release Candidate"
 
 /** See the table for DEFINED_VER_STATUS */
-#define DEFINED_VER_STATUS_SHORT  "b"
+#define DEFINED_VER_STATUS_SHORT  "rc"
 /// @}
 /*****************************************************************************/
 #endif //__VERSION_HEADER__