Review ALL examples

15 files changed, 205 insertions, 205 deletions

diff --git a/examples/shapes/shapes_basic_shapes.c b/examples/shapes/shapes_basic_shapes.c
index 67eea9d5..f7a8d02f 100644
--- a/examples/shapes/shapes_basic_shapes.c
+++ b/examples/shapes/shapes_basic_shapes.c
@@ -11,16 +11,16 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing");
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
diff --git a/examples/shapes/shapes_bouncing_ball.c b/examples/shapes/shapes_bouncing_ball.c
index 6b27c9dd..9f01ff14 100644
--- a/examples/shapes/shapes_bouncing_ball.c
+++ b/examples/shapes/shapes_bouncing_ball.c
@@ -11,58 +11,58 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //---------------------------------------------------------
     const int screenWidth = 800;
     const int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - bouncing ball");
-    
-	Vector2 ballPosition = { GetScreenWidth()/2, GetScreenHeight()/2 };
-	Vector2 ballSpeed = { 5.0f, 4.0f };
-	int ballRadius = 20;
-    
+
+    Vector2 ballPosition = { GetScreenWidth()/2, GetScreenHeight()/2 };
+    Vector2 ballSpeed = { 5.0f, 4.0f };
+    int ballRadius = 20;
+
     bool pause = 0;
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //----------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
         //-----------------------------------------------------
         if (IsKeyPressed(KEY_SPACE)) pause = !pause;
-        
+
         if (!pause)
         {
             ballPosition.x += ballSpeed.x;
             ballPosition.y += ballSpeed.y;
-            
+
             // Check walls collision for bouncing
             if ((ballPosition.x >= (GetScreenWidth() - ballRadius)) || (ballPosition.x <= ballRadius)) ballSpeed.x *= -1.0f;
             if ((ballPosition.y >= (GetScreenHeight() - ballRadius)) || (ballPosition.y <= ballRadius)) ballSpeed.y *= -1.0f;
         }
         else framesCounter++;
         //-----------------------------------------------------
-        
+
         // Draw
         //-----------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawCircleV(ballPosition, ballRadius, MAROON);
             DrawText("PRESS SPACE to PAUSE BALL MOVEMENT", 10, GetScreenHeight() - 25, 20, LIGHTGRAY);
-            
+
             // On pause, we draw a blinking message
             if (pause && ((framesCounter/30)%2)) DrawText("PAUSED", 350, 200, 30, GRAY);
 
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //-----------------------------------------------------
     }
@@ -71,6 +71,6 @@ int main()
     //---------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //----------------------------------------------------------
-    
+
     return 0;
 }
\ No newline at end of file
diff --git a/examples/shapes/shapes_collision_area.c b/examples/shapes/shapes_collision_area.c
index e61623ab..0deba0dd 100644
--- a/examples/shapes/shapes_collision_area.c
+++ b/examples/shapes/shapes_collision_area.c
@@ -12,89 +12,89 @@
 #include "raylib.h"
 #include <stdlib.h>     // Required for abs()
 
-int main()
+int main(void)
 {
     // Initialization
     //---------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - collision area");
-    
+
     // Box A: Moving box
     Rectangle boxA = { 10, GetScreenHeight()/2 - 50, 200, 100 };
-	int boxASpeedX = 4;
-	
+    int boxASpeedX = 4;
+
     // Box B: Mouse moved box
     Rectangle boxB = { GetScreenWidth()/2 - 30, GetScreenHeight()/2 - 30, 60, 60 };
-    
-    Rectangle boxCollision = { 0 };       // Collision rectangle
-    
+
+    Rectangle boxCollision = { 0 }; // Collision rectangle
+
     int screenUpperLimit = 40;      // Top menu limits
-    
-	bool pause = false;             // Movement pause
-	bool collision = false;         // Collision detection
-    
-    SetTargetFPS(60);
+
+    bool pause = false;             // Movement pause
+    bool collision = false;         // Collision detection
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //----------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
         //-----------------------------------------------------
         // Move box if not paused
-		if (!pause) boxA.x += boxASpeedX;
-        
+        if (!pause) boxA.x += boxASpeedX;
+
         // Bounce box on x screen limits
-		if (((boxA.x + boxA.width) >= GetScreenWidth()) || (boxA.x <= 0)) boxASpeedX *= -1;
-		
-		// Update player-controlled-box (box02)
-		boxB.x = GetMouseX() - boxB.width/2;
-		boxB.y = GetMouseY() - boxB.height/2;
-		
+        if (((boxA.x + boxA.width) >= GetScreenWidth()) || (boxA.x <= 0)) boxASpeedX *= -1;
+
+        // Update player-controlled-box (box02)
+        boxB.x = GetMouseX() - boxB.width/2;
+        boxB.y = GetMouseY() - boxB.height/2;
+
         // Make sure Box B does not go out of move area limits
-		if ((boxB.x + boxB.width) >= GetScreenWidth()) boxB.x = GetScreenWidth() - boxB.width;
-		else if (boxB.x <= 0) boxB.x = 0;
-		
-		if ((boxB.y + boxB.height) >= GetScreenHeight()) boxB.y = GetScreenHeight() - boxB.height;
-		else if (boxB.y <= screenUpperLimit) boxB.y = screenUpperLimit;
-        
+        if ((boxB.x + boxB.width) >= GetScreenWidth()) boxB.x = GetScreenWidth() - boxB.width;
+        else if (boxB.x <= 0) boxB.x = 0;
+
+        if ((boxB.y + boxB.height) >= GetScreenHeight()) boxB.y = GetScreenHeight() - boxB.height;
+        else if (boxB.y <= screenUpperLimit) boxB.y = screenUpperLimit;
+
         // Check boxes collision
         collision = CheckCollisionRecs(boxA, boxB);
-		
-		// Get collision rectangle (only on collision)
-		if (collision) boxCollision = GetCollisionRec(boxA, boxB);
-		
+
+        // Get collision rectangle (only on collision)
+        if (collision) boxCollision = GetCollisionRec(boxA, boxB);
+
         // Pause Box A movement
-		if (IsKeyPressed(KEY_SPACE)) pause = !pause;
+        if (IsKeyPressed(KEY_SPACE)) pause = !pause;
         //-----------------------------------------------------
-        
+
         // Draw
         //-----------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawRectangle(0, 0, screenWidth, screenUpperLimit, collision? RED : BLACK);
 
             DrawRectangleRec(boxA, GOLD);
             DrawRectangleRec(boxB, BLUE);
-            
+
             if (collision)
             {
                 // Draw collision area
                 DrawRectangleRec(boxCollision, LIME);
-                
+
                 // Draw collision message
                 DrawText("COLLISION!", GetScreenWidth()/2 - MeasureText("COLLISION!", 20)/2, screenUpperLimit/2 - 10, 20, BLACK);
-                
+
                 // Draw collision area
                 DrawText(FormatText("Collision Area: %i", (int)boxCollision.width*(int)boxCollision.height), GetScreenWidth()/2 - 100, screenUpperLimit + 10, 20, BLACK);
-            }     
+            }
 
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //-----------------------------------------------------
     }
@@ -103,6 +103,6 @@ int main()
     //---------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //----------------------------------------------------------
-    
+
     return 0;
 }
\ No newline at end of file
diff --git a/examples/shapes/shapes_colors_palette.c b/examples/shapes/shapes_colors_palette.c
index d6ac30a9..7322f7e5 100644
--- a/examples/shapes/shapes_colors_palette.c
+++ b/examples/shapes/shapes_colors_palette.c
@@ -13,7 +13,7 @@
 
 #define MAX_COLORS_COUNT    21          // Number of colors available
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -22,14 +22,14 @@ int main()
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - colors palette");
 
-    Color colors[MAX_COLORS_COUNT] = { 
+    Color colors[MAX_COLORS_COUNT] = {
         DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
         GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
         GREEN, SKYBLUE, PURPLE, BEIGE };
-                         
-    const char *colorNames[MAX_COLORS_COUNT] = { 
-        "DARKGRAY", "MAROON", "ORANGE", "DARKGREEN", "DARKBLUE", "DARKPURPLE", 
-        "DARKBROWN", "GRAY", "RED", "GOLD", "LIME", "BLUE", "VIOLET", "BROWN", 
+
+    const char *colorNames[MAX_COLORS_COUNT] = {
+        "DARKGRAY", "MAROON", "ORANGE", "DARKGREEN", "DARKBLUE", "DARKPURPLE",
+        "DARKBROWN", "GRAY", "RED", "GOLD", "LIME", "BLUE", "VIOLET", "BROWN",
         "LIGHTGRAY", "PINK", "YELLOW", "GREEN", "SKYBLUE", "PURPLE", "BEIGE" };
 
     Rectangle colorsRecs[MAX_COLORS_COUNT] = { 0 };     // Rectangles array
@@ -69,19 +69,19 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             DrawText("raylib colors palette", 28, 42, 20, BLACK);
             DrawText("press SPACE to see all colors", GetScreenWidth() - 180, GetScreenHeight() - 40, 10, GRAY);
 
             for (int i = 0; i < MAX_COLORS_COUNT; i++)    // Draw all rectangles
             {
                 DrawRectangleRec(colorsRecs[i], Fade(colors[i], colorState[i]? 0.6f : 1.0f));
-                
-                if (IsKeyDown(KEY_SPACE) || colorState[i]) 
+
+                if (IsKeyDown(KEY_SPACE) || colorState[i])
                 {
                     DrawRectangle(colorsRecs[i].x, colorsRecs[i].y + colorsRecs[i].height - 26, colorsRecs[i].width, 20, BLACK);
                     DrawRectangleLinesEx(colorsRecs[i], 6, Fade(BLACK, 0.3f));
-                    DrawText(colorNames[i], colorsRecs[i].x + colorsRecs[i].width - MeasureText(colorNames[i], 10) - 12, 
+                    DrawText(colorNames[i], colorsRecs[i].x + colorsRecs[i].width - MeasureText(colorNames[i], 10) - 12,
                              colorsRecs[i].y + colorsRecs[i].height - 20, 10, colors[i]);
                 }
             }
diff --git a/examples/shapes/shapes_draw_circle_sector.c b/examples/shapes/shapes_draw_circle_sector.c
index 597b85a7..ae6de5ff 100644
--- a/examples/shapes/shapes_draw_circle_sector.c
+++ b/examples/shapes/shapes_draw_circle_sector.c
@@ -16,7 +16,7 @@
 #define RAYGUI_IMPLEMENTATION
 #include "raygui.h"                 // Required for GUI controls
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -32,7 +32,7 @@ int main()
     int endAngle = 180;
     int segments = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
diff --git a/examples/shapes/shapes_draw_rectangle_rounded.c b/examples/shapes/shapes_draw_rectangle_rounded.c
index e36e2731..c183e88b 100644
--- a/examples/shapes/shapes_draw_rectangle_rounded.c
+++ b/examples/shapes/shapes_draw_rectangle_rounded.c
@@ -30,12 +30,12 @@ int main(void)
     int height = 100;
     int segments = 0;
     int lineThick = 1;
-    
+
     bool drawRect = false;
     bool drawRoundedRect = true;
     bool drawRoundedLines = false;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -45,20 +45,20 @@ int main(void)
         //----------------------------------------------------------------------------------
         Rectangle rec = { (GetScreenWidth() - width - 250)/2, (GetScreenHeight() - height)/2, width, height };
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-        
+
             DrawLine(560, 0, 560, GetScreenHeight(), Fade(LIGHTGRAY, 0.6f));
             DrawRectangle(560, 0, GetScreenWidth() - 500, GetScreenHeight(), Fade(LIGHTGRAY, 0.3f));
 
             if (drawRect) DrawRectangleRec(rec, Fade(GOLD, 0.6));
             if (drawRoundedRect) DrawRectangleRounded(rec, roundness, segments, Fade(MAROON, 0.2));
             if (drawRoundedLines) DrawRectangleRoundedLines(rec,roundness, segments, lineThick, Fade(MAROON, 0.4));
-        
+
             // Draw GUI controls
             //------------------------------------------------------------------------------
             width = GuiSliderBar((Rectangle){ 640, 40, 105, 20 }, "Width", width, 0, GetScreenWidth() - 300, true );
@@ -66,22 +66,22 @@ int main(void)
             roundness = GuiSliderBar((Rectangle){ 640, 140, 105, 20 }, "Roundness", roundness, 0.0f, 1.0f, true);
             lineThick = GuiSliderBar((Rectangle){ 640, 170, 105, 20 }, "Thickness", lineThick, 0, 20, true);
             segments = GuiSliderBar((Rectangle){ 640, 240, 105, 20}, "Segments", segments, 0, 60, true);
-            
+
             drawRoundedRect = GuiCheckBox((Rectangle){ 640, 320, 20, 20 }, "DrawRoundedRect", drawRoundedRect);
             drawRoundedLines = GuiCheckBox((Rectangle){ 640, 350, 20, 20 }, "DrawRoundedLines", drawRoundedLines);
             drawRect = GuiCheckBox((Rectangle){ 640, 380, 20, 20}, "DrawRect", drawRect);
             //------------------------------------------------------------------------------
-            
+
             DrawText(FormatText("MODE: %s", (segments >= 4)? "MANUAL" : "AUTO"), 640, 280, 10, (segments >= 4)? MAROON : DARKGRAY);
-            
+
             DrawFPS(10, 10);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------  
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_draw_ring.c b/examples/shapes/shapes_draw_ring.c
index 44a3ec5f..a90feab7 100644
--- a/examples/shapes/shapes_draw_ring.c
+++ b/examples/shapes/shapes_draw_ring.c
@@ -16,7 +16,7 @@
 #define RAYGUI_IMPLEMENTATION
 #include "raygui.h"                 // Required for GUI controls
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -29,16 +29,16 @@ int main()
 
     float innerRadius = 80.0f;
     float outerRadius = 190.0f;
-    
+
     int startAngle = 0;
     int endAngle = 360;
     int segments = 0;
-    
+
     bool drawRing = true;
     bool drawRingLines = false;
     bool drawCircleLines = false;
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -48,13 +48,13 @@ int main()
         //----------------------------------------------------------------------------------
         // NOTE: All variables update happens inside GUI control functions
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawLine(500, 0, 500, GetScreenHeight(), Fade(LIGHTGRAY, 0.6f));
             DrawRectangle(500, 0, GetScreenWidth() - 500, GetScreenHeight(), Fade(LIGHTGRAY, 0.3f));
 
@@ -66,27 +66,27 @@ int main()
             //------------------------------------------------------------------------------
             startAngle = GuiSliderBar((Rectangle){ 600, 40, 120, 20 }, "StartAngle", startAngle, -450, 450, true);
             endAngle = GuiSliderBar((Rectangle){ 600, 70, 120, 20 }, "EndAngle", endAngle, -450, 450, true);
-            
+
             innerRadius = GuiSliderBar((Rectangle){ 600, 140, 120, 20 }, "InnerRadius", innerRadius, 0, 100, true);
             outerRadius = GuiSliderBar((Rectangle){ 600, 170, 120, 20 }, "OuterRadius", outerRadius, 0, 200, true);
-            
+
             segments = GuiSliderBar((Rectangle){ 600, 240, 120, 20 }, "Segments", segments, 0, 100, true);
-            
+
             drawRing = GuiCheckBox((Rectangle){ 600, 320, 20, 20 }, "Draw Ring", drawRing);
             drawRingLines = GuiCheckBox((Rectangle){ 600, 350, 20, 20 }, "Draw RingLines", drawRingLines);
             drawCircleLines = GuiCheckBox((Rectangle){ 600, 380, 20, 20 }, "Draw CircleLines", drawCircleLines);
             //------------------------------------------------------------------------------
-            
+
             DrawText(FormatText("MODE: %s", (segments >= 4)? "MANUAL" : "AUTO"), 600, 270, 10, (segments >= 4)? MAROON : DARKGRAY);
-            
+
             DrawFPS(10, 10);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------  
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_easings_ball_anim.c b/examples/shapes/shapes_easings_ball_anim.c
index 4477203c..5bb2b4c6 100644
--- a/examples/shapes/shapes_easings_ball_anim.c
+++ b/examples/shapes/shapes_easings_ball_anim.c
@@ -11,9 +11,9 @@
 
 #include "raylib.h"
 
-#include "easings.h"            // Required for easing functions
+#include "easings.h"                // Required for easing functions
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -21,16 +21,16 @@ int main()
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - easings ball anim");
-    
+
     // Ball variable value to be animated with easings
     int ballPositionX = -100;
     int ballRadius = 20;
     float ballAlpha = 0.0f;
-    
+
     int state = 0;
     int framesCounter = 0;
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -42,7 +42,7 @@ int main()
         {
             framesCounter++;
             ballPositionX = EaseElasticOut(framesCounter, -100, screenWidth/2 + 100, 120);
-            
+
             if (framesCounter >= 120)
             {
                 framesCounter = 0;
@@ -53,7 +53,7 @@ int main()
         {
             framesCounter++;
             ballRadius = EaseElasticIn(framesCounter, 20, 500, 200);
-            
+
             if (framesCounter >= 200)
             {
                 framesCounter = 0;
@@ -64,7 +64,7 @@ int main()
         {
             framesCounter++;
             ballAlpha = EaseCubicOut(framesCounter, 0.0f, 1.0f, 200);
-            
+
             if (framesCounter >= 200)
             {
                 framesCounter = 0;
@@ -73,7 +73,7 @@ int main()
         }
         else if (state == 3)        // Reset state to play again
         {
-            if (IsKeyPressed(KEY_ENTER)) 
+            if (IsKeyPressed(KEY_ENTER))
             {
                 // Reset required variables to play again
                 ballPositionX = -100;
@@ -82,7 +82,7 @@ int main()
                 state = 0;
             }
         }
-        
+
         if (IsKeyPressed(KEY_R)) framesCounter = 0;
         //----------------------------------------------------------------------------------
 
@@ -94,15 +94,15 @@ int main()
 
             if (state >= 2) DrawRectangle(0, 0, screenWidth, screenHeight, GREEN);
             DrawCircle(ballPositionX, 200, ballRadius, Fade(RED, 1.0f - ballAlpha));
-            
+
             if (state == 3) DrawText("PRESS [ENTER] TO PLAY AGAIN!", 240, 200, 20, BLACK);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_easings_box_anim.c b/examples/shapes/shapes_easings_box_anim.c
index c74cb2a3..6805d531 100644
--- a/examples/shapes/shapes_easings_box_anim.c
+++ b/examples/shapes/shapes_easings_box_anim.c
@@ -13,7 +13,7 @@
 
 #include "easings.h"            // Required for easing functions
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -21,16 +21,16 @@ int main()
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - easings box anim");
-    
+
     // Box variables to be animated with easings
     Rectangle rec = { GetScreenWidth()/2, -100, 100, 100 };
     float rotation = 0.0f;
     float alpha = 1.0f;
-    
+
     int state = 0;
     int framesCounter = 0;
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -43,12 +43,12 @@ int main()
             case 0:     // Move box down to center of screen
             {
                 framesCounter++;
-                
+
                 // NOTE: Remember that 3rd parameter of easing function refers to
                 // desired value variation, do not confuse it with expected final value!
                 rec.y = EaseElasticOut(framesCounter, -100, GetScreenHeight()/2 + 100, 120);
 
-                if (framesCounter >= 120) 
+                if (framesCounter >= 120)
                 {
                     framesCounter = 0;
                     state = 1;
@@ -59,8 +59,8 @@ int main()
                 framesCounter++;
                 rec.height = EaseBounceOut(framesCounter, 100, -90, 120);
                 rec.width = EaseBounceOut(framesCounter, 100, GetScreenWidth(), 120);
-                
-                if (framesCounter >= 120) 
+
+                if (framesCounter >= 120)
                 {
                     framesCounter = 0;
                     state = 2;
@@ -70,8 +70,8 @@ int main()
             {
                 framesCounter++;
                 rotation = EaseQuadOut(framesCounter, 0.0f, 270.0f, 240);
-                
-                if (framesCounter >= 240) 
+
+                if (framesCounter >= 240)
                 {
                     framesCounter = 0;
                     state = 3;
@@ -81,8 +81,8 @@ int main()
             {
                 framesCounter++;
                 rec.height = EaseCircOut(framesCounter, 10, GetScreenWidth(), 120);
-                
-                if (framesCounter >= 120) 
+
+                if (framesCounter >= 120)
                 {
                     framesCounter = 0;
                     state = 4;
@@ -92,7 +92,7 @@ int main()
             {
                 framesCounter++;
                 alpha = EaseSineOut(framesCounter, 1.0f, -1.0f, 160);
-                
+
                 if (framesCounter >= 160)
                 {
                     framesCounter = 0;
@@ -101,7 +101,7 @@ int main()
             } break;
             default: break;
         }
-        
+
         // Reset animation at any moment
         if (IsKeyPressed(KEY_SPACE))
         {
@@ -112,7 +112,7 @@ int main()
             framesCounter = 0;
         }
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
@@ -120,7 +120,7 @@ int main()
             ClearBackground(RAYWHITE);
 
             DrawRectanglePro(rec, (Vector2){ rec.width/2, rec.height/2 }, rotation, Fade(BLACK, alpha));
-            
+
             DrawText("PRESS [SPACE] TO RESET BOX ANIMATION!", 10, GetScreenHeight() - 25, 20, LIGHTGRAY);
 
         EndDrawing();
@@ -128,7 +128,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------  
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_easings_rectangle_array.c b/examples/shapes/shapes_easings_rectangle_array.c
index 27bad5c9..9844af6a 100644
--- a/examples/shapes/shapes_easings_rectangle_array.c
+++ b/examples/shapes/shapes_easings_rectangle_array.c
@@ -2,7 +2,7 @@
 *
 *   raylib [shapes] example - easings rectangle array
 *
-*   NOTE: This example requires 'easings.h' library, provided on raylib/src. Just copy 
+*   NOTE: This example requires 'easings.h' library, provided on raylib/src. Just copy
 *   the library to same directory as example or make sure it's available on include path.
 *
 *   This example has been created using raylib 2.0 (www.raylib.com)
@@ -24,17 +24,17 @@
 
 #define PLAY_TIME_IN_FRAMES     240                 // At 60 fps = 4 seconds
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - easings rectangle array");
-    
+
     Rectangle recs[MAX_RECS_X*MAX_RECS_Y];
-    
+
     for (int y = 0; y < MAX_RECS_Y; y++)
     {
         for (int x = 0; x < MAX_RECS_X; x++)
@@ -45,12 +45,12 @@ int main()
             recs[y*MAX_RECS_X + x].height = RECS_HEIGHT;
         }
     }
-    
+
     float rotation = 0.0f;
     int framesCounter = 0;
-    int state = 0;                  // Rectangles animation state: 0-Playing, 1-Finished 
-    
-    SetTargetFPS(60);
+    int state = 0;                  // Rectangles animation state: 0-Playing, 1-Finished
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -62,16 +62,16 @@ int main()
         {
             framesCounter++;
 
-            for (int i = 0; i < MAX_RECS_X*MAX_RECS_Y; i++) 
+            for (int i = 0; i < MAX_RECS_X*MAX_RECS_Y; i++)
             {
                 recs[i].height = EaseCircOut(framesCounter, RECS_HEIGHT, -RECS_HEIGHT, PLAY_TIME_IN_FRAMES);
                 recs[i].width = EaseCircOut(framesCounter, RECS_WIDTH, -RECS_WIDTH, PLAY_TIME_IN_FRAMES);
-                
+
                 if (recs[i].height < 0) recs[i].height = 0;
                 if (recs[i].width < 0) recs[i].width = 0;
-                
+
                 if ((recs[i].height == 0) && (recs[i].width == 0)) state = 1;   // Finish playing
-                
+
                 rotation = EaseLinearIn(framesCounter, 0.0f, 360.0f, PLAY_TIME_IN_FRAMES);
             }
         }
@@ -79,13 +79,13 @@ int main()
         {
             // When animation has finished, press space to restart
             framesCounter = 0;
-            
-            for (int i = 0; i < MAX_RECS_X*MAX_RECS_Y; i++) 
+
+            for (int i = 0; i < MAX_RECS_X*MAX_RECS_Y; i++)
             {
                 recs[i].height = RECS_HEIGHT;
                 recs[i].width = RECS_WIDTH;
             }
-            
+
             state = 0;
         }
         //----------------------------------------------------------------------------------
@@ -110,7 +110,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_following_eyes.c b/examples/shapes/shapes_following_eyes.c
index e99a7e07..a36a8d67 100644
--- a/examples/shapes/shapes_following_eyes.c
+++ b/examples/shapes/shapes_following_eyes.c
@@ -13,7 +13,7 @@
 
 #include <math.h>       // Required for: atan2f()
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -21,19 +21,19 @@ int main()
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - following eyes");
-    
+
     Vector2 scleraLeftPosition = { GetScreenWidth()/2 - 100, GetScreenHeight()/2 };
     Vector2 scleraRightPosition = { GetScreenWidth()/2 + 100, GetScreenHeight()/2 };
     float scleraRadius = 80;
-    
+
     Vector2 irisLeftPosition = { GetScreenWidth()/2 - 100, GetScreenHeight()/2 };
     Vector2 irisRightPosition = { GetScreenWidth()/2 + 100, GetScreenHeight()/2};
     float irisRadius = 24;
-   
-    float angle;  
-    float dx, dy, dxx, dyy; 
-    
-    SetTargetFPS(60);
+
+    float angle = 0.0f;
+    float dx = 0.0f, dy = 0.0f, dxx = 0.0f, dyy = 0.0f;
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -43,13 +43,13 @@ int main()
         //----------------------------------------------------------------------------------
         irisLeftPosition = GetMousePosition();
         irisRightPosition = GetMousePosition();
-        
+
         // Check not inside the left eye sclera
         if (!CheckCollisionPointCircle(irisLeftPosition, scleraLeftPosition, scleraRadius - 20))
         {
             dx = irisLeftPosition.x - scleraLeftPosition.x;
             dy = irisLeftPosition.y - scleraLeftPosition.y;
-        
+
             angle = atan2f(dy, dx);
 
             dxx = (scleraRadius - irisRadius)*cosf(angle);
@@ -64,7 +64,7 @@ int main()
         {
             dx = irisRightPosition.x - scleraRightPosition.x;
             dy = irisRightPosition.y - scleraRightPosition.y;
-        
+
             angle = atan2f(dy, dx);
 
             dxx = (scleraRadius - irisRadius)*cosf(angle);
@@ -84,19 +84,19 @@ int main()
             DrawCircleV(scleraLeftPosition, scleraRadius, LIGHTGRAY);
             DrawCircleV(irisLeftPosition, irisRadius, BROWN);
             DrawCircleV(irisLeftPosition, 10, BLACK);
-            
+
             DrawCircleV(scleraRightPosition, scleraRadius, LIGHTGRAY);
             DrawCircleV(irisRightPosition, irisRadius, DARKGREEN);
             DrawCircleV(irisRightPosition, 10, BLACK);
-            
+
             DrawFPS(10, 10);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_lines_bezier.c b/examples/shapes/shapes_lines_bezier.c
index f4133459..3d4edcde 100644
--- a/examples/shapes/shapes_lines_bezier.c
+++ b/examples/shapes/shapes_lines_bezier.c
@@ -11,20 +11,20 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - cubic-bezier lines");
-    
+
     Vector2 start = { 0, 0 };
     Vector2 end = { screenWidth, screenHeight };
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -41,17 +41,17 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             DrawText("USE MOUSE LEFT-RIGHT CLICK to DEFINE LINE START and END POINTS", 15, 20, 20, GRAY);
 
             DrawLineBezier(start, end, 2.0f, RED);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/shapes/shapes_logo_raylib.c b/examples/shapes/shapes_logo_raylib.c
index be94988c..3e2d343f 100644
--- a/examples/shapes/shapes_logo_raylib.c
+++ b/examples/shapes/shapes_logo_raylib.c
@@ -11,16 +11,16 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes");
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
diff --git a/examples/shapes/shapes_logo_raylib_anim.c b/examples/shapes/shapes_logo_raylib_anim.c
index 9be1d963..b8558393 100644
--- a/examples/shapes/shapes_logo_raylib_anim.c
+++ b/examples/shapes/shapes_logo_raylib_anim.c
@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation");
 
@@ -35,7 +35,7 @@ int main()
     int state = 0;                  // Tracking animation states (State Machine)
     float alpha = 1.0f;             // Useful for fading
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
diff --git a/examples/shapes/shapes_rectangle_scaling.c b/examples/shapes/shapes_rectangle_scaling.c
index 036a1dd4..6940cbcd 100644
--- a/examples/shapes/shapes_rectangle_scaling.c
+++ b/examples/shapes/shapes_rectangle_scaling.c
@@ -15,23 +15,23 @@
 
 #define MOUSE_SCALE_MARK_SIZE   12
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - rectangle scaling mouse");
-    
+
     Rectangle rec = { 100, 100, 200, 80 };
-    
+
     Vector2 mousePosition = { 0 };
-    
+
     bool mouseScaleReady = false;
     bool mouseScaleMode = false;
-    
-    SetTargetFPS(60);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -40,25 +40,25 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         mousePosition = GetMousePosition();
-        
-        if (CheckCollisionPointRec(mousePosition, rec) && 
+
+        if (CheckCollisionPointRec(mousePosition, rec) &&
             CheckCollisionPointRec(mousePosition, (Rectangle){ rec.x + rec.width - MOUSE_SCALE_MARK_SIZE, rec.y + rec.height - MOUSE_SCALE_MARK_SIZE, MOUSE_SCALE_MARK_SIZE, MOUSE_SCALE_MARK_SIZE }))
         {
             mouseScaleReady = true;
             if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) mouseScaleMode = true;
         }
         else mouseScaleReady = false;
-        
+
         if (mouseScaleMode)
         {
             mouseScaleReady = true;
-            
+
             rec.width = (mousePosition.x - rec.x);
             rec.height = (mousePosition.y - rec.y);
-            
+
             if (rec.width < MOUSE_SCALE_MARK_SIZE) rec.width = MOUSE_SCALE_MARK_SIZE;
             if (rec.height < MOUSE_SCALE_MARK_SIZE) rec.height = MOUSE_SCALE_MARK_SIZE;
-            
+
             if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) mouseScaleMode = false;
         }
         //----------------------------------------------------------------------------------
@@ -68,15 +68,15 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             DrawText("Scale rectangle dragging from bottom-right corner!", 10, 10, 20, GRAY);
 
             DrawRectangleRec(rec, Fade(GREEN, 0.5f));
-            
-            if (mouseScaleReady) 
+
+            if (mouseScaleReady)
             {
                 DrawRectangleLinesEx(rec, 1, RED);
-                DrawTriangle((Vector2){ rec.x + rec.width - MOUSE_SCALE_MARK_SIZE, rec.y + rec.height }, 
+                DrawTriangle((Vector2){ rec.x + rec.width - MOUSE_SCALE_MARK_SIZE, rec.y + rec.height },
                              (Vector2){ rec.x + rec.width, rec.y + rec.height },
                              (Vector2){ rec.x + rec.width, rec.y + rec.height - MOUSE_SCALE_MARK_SIZE }, RED);
             }
@@ -86,7 +86,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------