Add Projectile Motion Physics Usage Example

.vscode/settings.json

@@ -1,5 +1,62 @@
 {
   "files.associations": {
     "*.mdx": "markdown"
-  }
+  },
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wcast-align",
+    "-Wconversion",
+    "-Wsign-conversion",
+    "-Wnull-dereference"
+  ],
+  "C_Cpp_Runner.msvcWarnings": [
+    "/W4",
+    "/permissive-",
+    "/w14242",
+    "/w14287",
+    "/w14296",
+    "/w14311",
+    "/w14826",
+    "/w44062",
+    "/w44242",
+    "/w14905",
+    "/w14906",
+    "/w14263",
+    "/w44265",
+    "/w14928"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false,
+  "C_Cpp_Runner.useUndefinedSanitizer": false,
+  "C_Cpp_Runner.useLeakSanitizer": false,
+  "C_Cpp_Runner.showCompilationTime": false,
+  "C_Cpp_Runner.useLinkTimeOptimization": false,
+  "C_Cpp_Runner.msvcSecureNoWarnings": false
 }

astro.config.mjs

@@ -11,13 +11,14 @@ import starlightDocSearch from '@astrojs/starlight-docsearch';
 import remarkHeadingID from 'remark-heading-id';
 import { loadEnv } from "vite";
 
-const { DOCSEARCH_API_ID } = loadEnv(process.env.DOCSEARCH_API_ID, process.cwd(), "");
-const { DOCSEARCH_API_SEARCH_KEY } = loadEnv(process.env.DOCSEARCH_API_SEARCH_KEY, process.cwd(), "");
-const { DOCSEARCH_INDEX_NAME } = loadEnv(process.env.DOCSEARCH_INDEX_NAME, process.cwd(), "");
+const env = loadEnv(process.env.NODE_ENV ?? "development", process.cwd(), "");
+const DOCSEARCH_API_ID = process.env.DOCSEARCH_API_ID || env.DOCSEARCH_API_ID;
+const DOCSEARCH_API_SEARCH_KEY = process.env.DOCSEARCH_API_SEARCH_KEY || env.DOCSEARCH_API_SEARCH_KEY;
+const DOCSEARCH_INDEX_NAME = process.env.DOCSEARCH_INDEX_NAME || env.DOCSEARCH_INDEX_NAME;
+const hasDocSearchConfig = Boolean(DOCSEARCH_API_ID && DOCSEARCH_API_SEARCH_KEY && DOCSEARCH_INDEX_NAME);
 
-if (!DOCSEARCH_API_ID || !DOCSEARCH_API_SEARCH_KEY || !DOCSEARCH_INDEX_NAME) {
-  console.error("Algolia DocSearch enviroment variables are invalid. Please check configuration!");
-  process.exit(1);
+if (!hasDocSearchConfig) {
+  console.warn("Algolia DocSearch environment variables are missing. Continuing build without DocSearch.");
 }
 
 // https://astro.build/config
@@ -36,11 +37,15 @@ export default defineConfig({
         starlightLinksValidator({
           errorOnRelativeLinks: true,
         }),
-        starlightDocSearch({
-          appId: DOCSEARCH_API_ID,
-          apiKey: DOCSEARCH_API_SEARCH_KEY,
-          indexName: DOCSEARCH_INDEX_NAME,
-        }),
+        ...(hasDocSearchConfig
+          ? [
+              starlightDocSearch({
+                appId: DOCSEARCH_API_ID,
+                apiKey: DOCSEARCH_API_SEARCH_KEY,
+                indexName: DOCSEARCH_INDEX_NAME,
+              }),
+            ]
+          : []),
       ],
       expressiveCode: {
         // theme: ["github-dark", "github-light"],

public/usage-examples/physics/celestial_mechanics-1-example-oop.cs

@@ -0,0 +1,97 @@
+using SplashKitSDK;
+using System.Collections.Generic;
+
+namespace CelestialMechanics
+{
+    public class Program
+    {
+        // Constants for physics
+        private const double G = 10.0; // Scaled Gravitational Constant for visual appeal
+        private const int WINDOW_WIDTH = 800;
+        private const int WINDOW_HEIGHT = 600;
+
+        public static void Main()
+        {
+            SplashKit.OpenWindow("Celestial Mechanics", WINDOW_WIDTH, WINDOW_HEIGHT);
+
+            // Load a simple circle bitmap for planets
+            Bitmap planetBmp = SplashKit.CreateBitmap("planet", 20, 20);
+            SplashKit.ClearBitmap(planetBmp, SplashKit.ColorTransparent());
+            SplashKit.FillCircleOnBitmap(planetBmp, SplashKit.ColorWhite(), 10, 10, 10);
+
+            // Create 3 planetary Sprites with varying masses
+            // Sun-like mass
+            Sprite sun = SplashKit.CreateSprite(planetBmp);
+            SplashKit.SpriteSetX(sun, WINDOW_WIDTH / 2 - 10);
+            SplashKit.SpriteSetY(sun, WINDOW_HEIGHT / 2 - 10);
+            SplashKit.SpriteSetMass(sun, 1000.0);
+
+            // Planet-like mass
+            Sprite planet = SplashKit.CreateSprite(planetBmp);
+            SplashKit.SpriteSetX(planet, WINDOW_WIDTH / 2 + 150);
+            SplashKit.SpriteSetY(planet, WINDOW_HEIGHT / 2 - 10);
+            SplashKit.SpriteSetMass(planet, 10.0);
+            SplashKit.SpriteSetVelocity(planet, SplashKit.VectorTo(0, 8)); // Vertical tangent velocity
+
+            // Moon-like mass
+            Sprite moon = SplashKit.CreateSprite(planetBmp);
+            SplashKit.SpriteSetX(moon, WINDOW_WIDTH / 2 + 170);
+            SplashKit.SpriteSetY(moon, WINDOW_HEIGHT / 2 - 10);
+            SplashKit.SpriteSetMass(moon, 1.0);
+            SplashKit.SpriteSetVelocity(moon, SplashKit.VectorTo(0, 10));
+
+            List<Sprite> bodies = new List<Sprite> { sun, planet, moon };
+
+            while (!SplashKit.QuitRequested())
+            {
+                SplashKit.ProcessEvents();
+
+                // N-Body Gravity Calculation
+                for (int i = 0; i < bodies.Count; i++)
+                {
+                    for (int j = 0; j < bodies.Count; j++)
+                    {
+                        if (i == j) continue;
+
+                        // Position difference
+                        Point2D p1 = SplashKit.SpritePosition(bodies[i]);
+                        Point2D p2 = SplashKit.SpritePosition(bodies[j]);
+
+                        // direction = p2 - p1
+                        Vector2D direction = SplashKit.VectorTo(p2.X - p1.X, p2.Y - p1.Y);
+                        double distance = SplashKit.VectorMagnitude(direction);
+
+                        // Prevent division by zero and extreme forces when overlapping
+                        if (distance < 5.0) distance = 5.0;
+
+                        // F = G * (m1 * m2) / r^2
+                        double forceMagnitude = (G * SplashKit.SpriteMass(bodies[i]) * SplashKit.SpriteMass(bodies[j])) / (distance * distance);
+
+                        // Apply force to body i towards body j (Acceleration = F/m)
+                        Vector2D forceVector = SplashKit.VectorMultiply(SplashKit.UnitVector(direction), forceMagnitude);
+                        Vector2D acceleration = SplashKit.VectorMultiply(forceVector, 1.0 / SplashKit.SpriteMass(bodies[i]));
+                        SplashKit.SpriteSetVelocity(bodies[i], SplashKit.VectorAdd(SplashKit.SpriteVelocity(bodies[i]), acceleration));
+                    }
+                }
+
+                // Update movement
+                foreach (Sprite body in bodies)
+                {
+                    SplashKit.UpdateSprite(body);
+                }
+
+                // Rendering
+                SplashKit.ClearScreen(SplashKit.ColorBlack());
+
+                foreach (Sprite body in bodies)
+                {
+                    SplashKit.DrawSprite(body);
+                }
+
+                SplashKit.RefreshScreen(60);
+            }
+
+            SplashKit.CloseAllWindows();
+        }
+    }
+}

public/usage-examples/physics/celestial_mechanics-1-example-top-level.cs

@@ -0,0 +1,88 @@
+using SplashKitSDK;
+using static SplashKitSDK.SplashKit;
+
+// Constants for physics
+const double G = 10.0; // Scaled Gravitational Constant for visual appeal
+const int WINDOW_WIDTH = 800;
+const int WINDOW_HEIGHT = 600;
+
+OpenWindow("Celestial Mechanics", WINDOW_WIDTH, WINDOW_HEIGHT);
+
+// Load a simple circle bitmap for planets
+Bitmap planetBmp = CreateBitmap("planet", 20, 20);
+ClearBitmap(planetBmp, ColorTransparent());
+FillCircleOnBitmap(planetBmp, ColorWhite(), 10, 10, 10);
+
+// Create 3 planetary Sprites with varying masses
+// Sun-like mass
+Sprite sun = CreateSprite(planetBmp);
+SpriteSetX(sun, WINDOW_WIDTH / 2 - 10);
+SpriteSetY(sun, WINDOW_HEIGHT / 2 - 10);
+SpriteSetMass(sun, 1000.0);
+
+// Planet-like mass
+Sprite planet = CreateSprite(planetBmp);
+SpriteSetX(planet, WINDOW_WIDTH / 2 + 150);
+SpriteSetY(planet, WINDOW_HEIGHT / 2 - 10);
+SpriteSetMass(planet, 10.0);
+SpriteSetVelocity(planet, VectorTo(0, 8)); // Vertical tangent velocity
+
+// Moon-like mass
+Sprite moon = CreateSprite(planetBmp);
+SpriteSetX(moon, WINDOW_WIDTH / 2 + 170);
+SpriteSetY(moon, WINDOW_HEIGHT / 2 - 10);
+SpriteSetMass(moon, 1.0);
+SpriteSetVelocity(moon, VectorTo(0, 10));
+
+Sprite[] bodies = { sun, planet, moon };
+
+while (!QuitRequested())
+{
+    ProcessEvents();
+
+    // N-Body Gravity Calculation
+    for (int i = 0; i < bodies.Length; i++)
+    {
+        for (int j = 0; j < bodies.Length; j++)
+        {
+            if (i == j) continue;
+
+            // Position difference
+            Point2D p1 = SpritePosition(bodies[i]);
+            Point2D p2 = SpritePosition(bodies[j]);
+
+            // direction = p2 - p1
+            Vector2D direction = VectorTo(p2.X - p1.X, p2.Y - p1.Y);
+            double distance = VectorMagnitude(direction);
+
+            // Prevent division by zero and extreme forces when overlapping
+            if (distance < 5.0) distance = 5.0;
+
+            // F = G * (m1 * m2) / r^2
+            double forceMagnitude = (G * SpriteMass(bodies[i]) * SpriteMass(bodies[j])) / (distance * distance);
+
+            // Apply force to body i towards body j (Acceleration = F/m)
+            Vector2D forceVector = VectorMultiply(UnitVector(direction), forceMagnitude);
+            Vector2D acceleration = VectorMultiply(forceVector, 1.0 / SpriteMass(bodies[i]));
+            SpriteSetVelocity(bodies[i], VectorAdd(SpriteVelocity(bodies[i]), acceleration));
+        }
+    }
+
+    // Update movement
+    foreach (Sprite body in bodies)
+    {
+        UpdateSprite(body);
+    }
+
+    // Rendering
+    ClearScreen(ColorBlack());
+
+    foreach (Sprite body in bodies)
+    {
+        DrawSprite(body);
+    }
+
+    RefreshScreen(60);
+}
+
+CloseAllWindows();

public/usage-examples/physics/celestial_mechanics-1-example.cpp

@@ -0,0 +1,94 @@
+#include "splashkit.h"
+#include <vector>
+
+// Constants for physics
+const double G = 10.0; // Scaled Gravitational Constant for visual appeal
+const int WINDOW_WIDTH = 800;
+const int WINDOW_HEIGHT = 600;
+
+int main()
+{
+    open_window("Celestial Mechanics", WINDOW_WIDTH, WINDOW_HEIGHT);
+
+    // Load a simple circle bitmap for planets
+    bitmap planet_bmp = create_bitmap("planet", 20, 20);
+    clear_bitmap(planet_bmp, COLOR_TRANSPARENT);
+    fill_circle_on_bitmap(planet_bmp, COLOR_WHITE, 10, 10, 10);
+
+    // Create 3 planetary Sprites with varying masses
+    // Sun-like mass
+    sprite sun = create_sprite(planet_bmp);
+    sprite_set_x(sun, WINDOW_WIDTH / 2 - 10);
+    sprite_set_y(sun, WINDOW_HEIGHT / 2 - 10);
+    sprite_set_mass(sun, 1000.0);
+
+    // Planet-like mass
+    sprite planet = create_sprite(planet_bmp);
+    sprite_set_x(planet, WINDOW_WIDTH / 2 + 150);
+    sprite_set_y(planet, WINDOW_HEIGHT / 2 - 10);
+    sprite_set_mass(planet, 10.0);
+    sprite_set_velocity(planet, vector_to(0, 8)); // Vertical tangent velocity
+
+    // Moon-like mass
+    sprite moon = create_sprite(planet_bmp);
+    sprite_set_x(moon, WINDOW_WIDTH / 2 + 170);
+    sprite_set_y(moon, WINDOW_HEIGHT / 2 - 10);
+    sprite_set_mass(moon, 1.0);
+    sprite_set_velocity(moon, vector_to(0, 10));
+
+    std::vector<sprite> bodies;
+    bodies.push_back(sun);
+    bodies.push_back(planet);
+    bodies.push_back(moon);
+
+    while (!quit_requested())
+    {
+        process_events();
+
+        // N-Body Gravity Calculation
+        for (int i = 0; i < bodies.size(); i++)
+        {
+            for (int j = 0; j < bodies.size(); j++)
+            {
+                if (i == j) continue;
+
+                // Position difference
+                point_2d p1 = sprite_position(bodies[i]);
+                point_2d p2 = sprite_position(bodies[j]);
+
+                vector_2d direction = vector_to(p2.x - p1.x, p2.y - p1.y);
+                double distance = vector_magnitude(direction);
+
+                // Prevent division by zero and extreme forces when overlapping
+                if (distance < 5.0) distance = 5.0;
+
+                // F = G * (m1 * m2) / r^2
+                double force_magnitude = (G * sprite_mass(bodies[i]) * sprite_mass(bodies[j])) / (distance * distance);
+
+                // Apply force to body i towards body j (F = m*a -> a = F/m)
+                vector_2d force_vector = vector_multiply(unit_vector(direction), force_magnitude);
+                vector_2d acceleration = vector_multiply(force_vector, 1.0 / sprite_mass(bodies[i]));
+                sprite_set_velocity(bodies[i], vector_add(sprite_velocity(bodies[i]), acceleration));
+            }
+        }
+
+        // Update movement
+        for (unsigned int i = 0; i < bodies.size(); i++)
+        {
+            update_sprite(bodies[i]);
+        }
+
+        // Rendering
+        clear_screen(COLOR_BLACK);
+
+        for (unsigned int i = 0; i < bodies.size(); i++)
+        {
+            draw_sprite(bodies[i]);
+        }
+
+        refresh_screen(60);
+    }
+
+    close_all_windows();
+    return 0;
+}