Update to v1.2.3-beta

Patrick Rye · Patrick Rye · commit 105c6b91f9f7 · 2015-09-21T11:03:36.000-04:00
21 September 2015
   Released version 1.2.3-Beta

     Change log:

-Removed: Sky image (replaced with SDL_SetRenderDrawColor)

-Added: Cannonballs are now more transparent the less mass they have

-Removed: My attempt at making parts of the ball image transparent (it
wasn't working)
  -Changed: Reduced fTimetoSizeRatio from 1.2458 to
0.0124
  -Added: Namespace Equations to hold equation values
  -Changed:
Screen background color from White to Black
  -Changed: Ball color from
Black to White
  -Changed: Pixel color from Black to White
  -Added:
Ball Path is now drawn on screen (holds so many past points, can be
enabled in config file)
diff --git a/ChangesLog.txt b/ChangesLog.txt
@@ -1,3 +1,17 @@
+21 September 2015
+   Released version 1.2.3-Beta
+
+     Change log:
+        -Removed: Sky image (replaced with SDL_SetRenderDrawColor)
+        -Added: Cannonballs are now more transparent the less mass they have
+		-Removed: My attempt at making parts of the ball image transparent (it wasn't working)
+		-Changed: Reduced fTimetoSizeRatio from 1.2458 to 0.0124
+		-Added: Namespace Equations to hold equation values
+		-Changed: Screen background color from White to Black
+		-Changed: Ball color from Black to White
+		-Changed: Pixel color from Black to White
+		-Added: Ball Path is now drawn on screen (holds so many past points, can be enabled in config file)
+
 18 September 2015
    Released version 1.2.2-Beta
 
diff --git a/project/SDL-Cannon-Simulation.cbp b/project/SDL-Cannon-Simulation.cbp
@@ -135,7 +135,6 @@
 		<Unit filename="../src/global.h" />
 		<Unit filename="../src/image_ball.xpm" />
 		<Unit filename="../src/image_pixel.xpm" />
-		<Unit filename="../src/image_sky.xpm" />
 		<Unit filename="../src/main.cpp" />
 		<Unit filename="../src/screen.cpp" />
 		<Unit filename="../src/screen.h" />
diff --git a/src/cannonball.cpp b/src/cannonball.cpp
@@ -104,22 +104,36 @@ void clsCannonball::update(double newdeltat) {
     if (total_v < Global::Physics::fMinVelocity || isnan(total_v) ) {
         blnstarted = false;
         if (Global::blnDebugMode) {
-            if ( isnan(total_v) ) {printf("Ball vel is NaN; killing it\n");}
+            if ( isnan(total_v) ) {printf("Ball velocity is NaN; killing it\n");}
             else {printf("Ball moving too slow; killing it\n");}
         } //end if debug mode
     } //end if should kill
 	show();
 }
 /**********************************************************************************************************************************************/
-void clsCannonball::setSDLScreen(SDL_Texture* SDLball, WINATT SDLwindow) {
+void clsCannonball::setSDLScreen(SDL_Texture* SDLball, SDL_Texture* SDLpxel, WINATT SDLwindow) {
     ball = SDLball;
+    pixel = SDLpxel;
     SDL_QueryTexture(ball,NULL,NULL, &Screen_place.w, &Screen_place.h);
     window = SDLwindow;
 }
 /**********************************************************************************************************************************************/
 void clsCannonball::show() {
     Screen_place.x = place.x;
     Screen_place.y = window.height - place.y;
+
+    if (Global::Config.values.blnDrawPathOnScreen) { drawPath(place); }
+
+    Uint8 alpha = 0xFF;
+    double dblAlpha;
+
+    dblAlpha = (double) Global::Equations::fMassAlphaRatio * log(props.mass) + Global::Equations::fMassAlphaOffset;
+    alpha = dblAlpha < (double) Global::Equations::uAlphaMinimum ? (Uint8) Global::Equations::uAlphaMinimum : (Uint8) dblAlpha;
+    alpha = dblAlpha > 255.0 ? 255 : (Uint8) dblAlpha;
+
+    //set the ball alpha
+    SDL_SetTextureAlphaMod(ball, alpha);
+
     //Place the ball
     SDL_RenderCopy(window.ren,ball,NULL,&Screen_place);
 }
@@ -174,3 +188,25 @@ BOX clsCannonball::getBOX() {
     return CollisionBox;
 }
 /**********************************************************************************************************************************************/
+void clsCannonball::drawPath(LOC newplace) {
+    static uint UpdatesSinceLast;
+
+    //If there have been enough updates since the last time the path was updated,
+    //then update the path array otherwise inc updates
+    if ( UpdatesSinceLast >= 25 ) {
+        UpdatesSinceLast = 0;
+        //First move all the old locations down one spot in the array
+        for (uint i = 1; i < DEFINED_MAXNUMPASTPOINTS; i++) { path[i] = path[i-1]; }
+        //Now put the new location into the latest spot
+        path[0] = newplace;
+    } else { UpdatesSinceLast++; } //end if update points
+    //Now draw the path
+    SDL_Rect dst;
+    dst.w = dst.h = 1;
+    for (uint i = 0; i < DEFINED_MAXNUMPASTPOINTS; i++) {
+        dst.y = window.height - (uint)(path[i].y - Screen_place.h / 2);
+        dst.x = (uint)(path[i].x + Screen_place.w / 2);
+        SDL_RenderCopy(window.ren, pixel, NULL, &dst);
+    } //end for
+}
+/**********************************************************************************************************************************************/
diff --git a/src/cannonball.h b/src/cannonball.h
@@ -10,6 +10,7 @@
 #include "screen.h"
 /**********************************************************************************************************************************************/
 #define PI 3.1415926535897
+#define DEFINED_MAXNUMPASTPOINTS 5
 /**********************************************************************************************************************************************/
 struct stcDoubleValues {
     double x;
@@ -44,7 +45,7 @@ class clsCannonball {
         void setplace(LOC);
 
         void update(double);
-        void setSDLScreen(SDL_Texture*, WINATT);
+        void setSDLScreen(SDL_Texture*, SDL_Texture*, WINATT);
         dblXY getVelocity(void);
         void setVelocity(dblXY);
         PP getPhysicalProps(void);
@@ -57,6 +58,7 @@ class clsCannonball {
         bool blnDragEnabled;
 
         SDL_Texture* ball;
+        SDL_Texture* pixel;
         WINATT window;
 
         BOX CollisionBox;
@@ -68,9 +70,12 @@ class clsCannonball {
         dblXY acc;
         PP props;
 
+        LOC path[DEFINED_MAXNUMPASTPOINTS];
+
         void enableDrag(void);
         double deltat;
         void show(void);
+        void drawPath(LOC);
         void Drag_calcvalues(void);
         void Drag_updateacc(void);
 };
diff --git a/src/config.cpp b/src/config.cpp
@@ -10,6 +10,7 @@ clsConfig::clsConfig() {
     //Set default values
     values.blnLogging = false;
     values.blnDragMode = false;
+    values.blnDrawPathOnScreen = false;
     values.uintScreenWidth = 640;
     values.uintScreenHeight = 480;
 #if defined(_AIX)
@@ -56,6 +57,7 @@ void clsConfig::make(void) {
     fprintf(configFile,"Screen Height: %u\n",values.uintScreenHeight);
     fprintf(configFile,"Log Ball's path: %u\n", (values.blnLogging ? 1 : 0) ) ;
     fprintf(configFile,"Enable Drag Mode (experimental): %u\n", (values.blnDragMode ? 1 : 0) );
+    fprintf(configFile,"Draw Ball path on screen: %u\n", (values.blnDrawPathOnScreen ? 1 : 0) );
 	fclose(configFile);
 }
 /**********************************************************************************************************************************************/
@@ -89,6 +91,12 @@ void clsConfig::load(void) {
 	if(Global::blnDebugMode) {printf("Enable Drag \t %d\n",intTempBool);}
 	values.blnDragMode = (intTempBool == 1);
 
+    fgets(chrTempString,50,configFile);
+	intValuesScanned = sscanf(chrTempString, "%*s %*s %*s %*s %*s %d",&intTempBool);
+	if (intValuesScanned < 1) {printf("ERROR!"); intTempBool = 0;}
+	if(Global::blnDebugMode) {printf("Enable Screen Path \t %d\n",intTempBool);}
+	values.blnDrawPathOnScreen = (intTempBool == 1);
+
 	fclose(configFile);
 	printf("\n\n");
 }
@@ -127,7 +135,7 @@ void clsConfig::Check(void) {
 			printf("Current config file out of date. Making new one.\n");
 			fclose(configFile);
 			make();
-		} else { load();}
+		} else { load(); }
 	} //end if exists
 }
 /**********************************************************************************************************************************************/
diff --git a/src/config.h b/src/config.h
@@ -14,6 +14,7 @@ struct ConfigValues {
 	uint uintScreenHeight;
 	bool blnLogging;
 	bool blnDragMode;
+	bool blnDrawPathOnScreen;
 	char* OperatingSystem;
 };
 
diff --git a/src/global.h b/src/global.h
@@ -19,12 +19,18 @@ namespace Global {
         extern const float fKineticFriction;
         extern const float fDensityAir;
         extern const float fRecoil;
-        extern const float fVelocityScalar;
         extern const float fMinVelocity;
         extern const float fCoefficientRestitution;
-        extern const float fTimetoSizeRatio;
         extern const uchar CollisionMethod;
     }
+
+    namespace Equations {
+        extern const float fVelocityScalar;
+        extern const float fTimetoSizeRatio;
+        extern const float fMassAlphaRatio;
+        extern const float fMassAlphaOffset;
+        extern const uchar uAlphaMinimum;
+    }
 }
 /**********************************************************************************************************************************************/
 #endif // __GLOBAL_H_INCLUDED__
diff --git a/src/image_ball.xpm b/src/image_ball.xpm
@@ -1,21 +1,29 @@
 /* XPM */
 static char * image_ball_xpm[] = {
-"10 10 8 1",
-" 	c #FFFFFF",
-".	c #828282",
-"+	c #454545",
-"@	c #A8A8A8",
-"#	c #2C2C2C",
-"$	c #070707",
-"%	c #060606",
-"&	c #050505",
-"   .++.   ",
-" @#$%%$#@ ",
-" #%&&&&%# ",
-".$&&&&&&$.",
-"+%&&&&&&%+",
-"+%&&&&&&%+",
-".$&&&&&&$.",
-" #%&&&&%# ",
-" @#$%%$#@ ",
-"   .++.   "};
+"10 10 16 1",
+" 	g #000000",
+".	g #CACACA",
+"+	g #F9F9F9",
+"@	g #D5D5D5",
+"#	g #888888",
+"$	g #FDFDFD",
+"%	g #FFFFFF",
+"&	g #FEFEFE",
+"*	g #969696",
+"=	g #FCFCFC",
+"-	g #EEEEEE",
+";	g #F5F5F5",
+">	g #BBBBBB",
+",	g #C6C6C6",
+"'	g #EFEFEF",
+")	g #F6F6F6",
+"   .++@   ",
+" #$%%%%&* ",
+" $%%%%%%& ",
+".%%%%%%%%@",
+"=%%%%%%%%&",
+"=%%%%%%%%&",
+"-%%%%%%%%;",
+" &%%%%%%% ",
+" >%%%%%%, ",
+"   '&&)   "};
diff --git a/src/image_pixel.xpm b/src/image_pixel.xpm
@@ -1,5 +1,5 @@
 /* XPM */
 static char * image_pixel_xpm[] = {
 "1 1 1 1",
-" 	c #000000",
+" 	c #FFFFFF",
 " "};
diff --git a/src/image_sky.xpm b/src/image_sky.xpm
diff --git a/src/main.cpp b/src/main.cpp
@@ -1,7 +1,5 @@
-/* TODO (GamerMan7799#4#): Show path of each ball on the screen */
 /* 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#1#): Balls are more transparent the less mass it has. */
 /**********************************************************************************************************************************************************************/
 #include <SDL2/SDL.h>
 #include <cstdio>
@@ -35,19 +33,24 @@ namespace Global {
     clsConfig Config;
     namespace Physics { //hold physics values in one place for future reference
         const uint uBallDensity = 7850; //Density of the ball in kg/m^3 (7850 is steel)
-        const float fGravity = -9.81;
-        const float fDragCofficient = 0.47;
-        //Friction values based on Concrete and Steel
-        const float fKineticFriction = 0.36;
-        const float fDensityAir = 1.2754; //Density of air
+        const float fGravity = -9.81; //acceleration due to gravity in m/s^2
+        const float fDragCofficient = 0.47; //Drag coefficient in the air
+        const float fKineticFriction = 0.36; //Friction values based on Concrete and Steel
+        const float fDensityAir = 1.2754; //Density of air (in kg/m^3)
         const float fRecoil = -0.56; //the multiplier of the velocity when a ball hits the walls / floor
-        const float fVelocityScalar = 1; //Changing this effects the fire velocity
         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 float fTimetoSizeRatio = 1.2458; //One second of holding down the mouse button = this many meters for the ball
+        //(see https://en.wikipedia.org/wiki/Coefficient_of_restitution for more info)
         const uchar CollisionMethod = CollideInelastic;
     }
+
+    namespace Equations { //Holds Values for different equations that are not physics related
+        const float fVelocityScalar = 1; //Changing this effects the ratio of the line to the velocity when creating a cannonball
+        const float fTimetoSizeRatio = 0.0124; //One second of holding down the mouse button = this many meters for the ball
+        const float fMassAlphaRatio = 47.568; //The ratio between mass and its alpha (transparent) value
+        const float fMassAlphaOffset = 152.18; //The offset for the equation of mass to alpha value
+        const uchar uAlphaMinimum = 30; //the lowest that the alpha value is allowed to be
+    }
 }
 /**********************************************************************************************************************************************************************/
 //This is the maximum number of cannonballs which can be "alive" at a time
@@ -68,7 +71,9 @@ int main(int argc, char *argv[]) {
 	if ( !CannonWindow.getSDLStarted() ) {return 1;} //exit program if there was an error
 
     //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.getWindow() ); }
+    for (uint i = 0; i < DEFINED_CANNONBALL_LIMIT; i++) {
+        Cannonballs[i].setSDLScreen( CannonWindow.getBallTexture(), CannonWindow.getPixelTexture(), CannonWindow.getWindow() );
+    }
 
     bool quit = false;
     bool holding = false;
@@ -135,11 +140,11 @@ void addNewCannonball(LOC mouseC, LOC mouseO, double HoldTime ) {
     //Get location, vel, and angle
     double fire_v;
     double angle;
-    double radius = (double)Global::Physics::fTimetoSizeRatio * HoldTime;
+    double radius = (double)Global::Equations::fTimetoSizeRatio * HoldTime;
 
     //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;
+    fire_v /= (double) Global::Equations::fVelocityScalar;
 
     //if the mouse if pointing straight up or straight down make the angle 90
     //Otherwise calculate the angle with atan.
diff --git a/src/screen.cpp b/src/screen.cpp
diff --git a/src/screen.h b/src/screen.h
diff --git a/src/version.h b/src/version.h
