Add Projectile Motion Physics Usage Example

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)); // Horizontal 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;
+}

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

@@ -0,0 +1,83 @@
+from splashkit import *
+
+# Constants for physics
+G = 10.0 # Scaled Gravitational Constant for visual appeal
+WINDOW_WIDTH = 800
+WINDOW_HEIGHT = 600
+
+def main():
+    open_window("Celestial Mechanics", WINDOW_WIDTH, WINDOW_HEIGHT)
+
+    # Load a simple circle bitmap for planets
+    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
+    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
+    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
+    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))
+
+    bodies = [sun, planet, moon]
+
+    while not quit_requested():
+        process_events()
+
+        # N-Body Gravity Calculation
+        for i in range(len(bodies)):
+            for j in range(len(bodies)):
+                if i == j:
+                    continue
+
+                # Position difference
+                p1 = sprite_position(bodies[i])
+                p2 = sprite_position(bodies[j])
+
+                # direction = p2 - p1
+                direction = vector_to(p2.x - p1.x, p2.y - p1.y)
+                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
+                force_magnitude = (G * sprite_mass(bodies[i]) * sprite_mass(bodies[j])) / (distance * distance)
+
+                # Apply force to body i towards body j (a = F/m)
+                force_vector = vector_multiply(unit_vector(direction), force_magnitude)
+                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 body in bodies:
+            update_sprite(body)
+
+        # Rendering
+        clear_screen(color_black())
+
+        for body in bodies:
+            draw_sprite(body)
+
+        refresh_screen(60)
+
+    close_all_windows()
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,2 @@
+Celestial Mechanics Integration Example
+

scripts/json-files/api.json

@@ -63274,6 +63274,17 @@
     "brief": "SplashKit Collisions library allow you to perform tests between\nbitmaps, sprites and shapes to determin if a collision has occured.Provides matrix functions to work on 2d coordinates.Provides vector functions to work on vectors.",
     "description": "",
     "functions": [
+      {
+        "signature": "void celestial_mechanics();",
+        "name": "celestial_mechanics",
+        "unique_global_name": "celestial_mechanics",
+        "description": "Integrated example showing N-body gravity simulation using Sprites and Vectors.",
+        "signatures": {
+          "cpp": ["void celestial_mechanics()"],
+          "python": ["def celestial_mechanics():"],
+          "csharp": ["public static void SplashKit.CelestialMechanics();"]
+        }
+      },
       {
         "signature": "bool bitmap_circle_collision(bitmap bmp,const point_2d &pt,const circle &circ);",
         "name": "bitmap_circle_collision",