Add nbody wrapper functionality

modules.json

@@ -111,5 +111,10 @@
  },
  "communication": {
  "tabs": []
+ },
+ "nbody": {
+ "tabs": [
+ "Nbody"
+ ]
  }
 }

package.json

@@ -61,7 +61,7 @@
  "@types/plotly.js-dist": "npm:@types/plotly.js",
  "@types/react": "^18.2.0",
  "@types/react-dom": "^18.2.0",
- "@types/three": "^0.161.2",
+ "@types/three": "^0.163.0",
  "@vitejs/plugin-react": "^4.0.4",
  "acorn": "^8.8.1",
  "acorn-jsx": "^5.3.2",
@@ -109,6 +109,7 @@
  "js-slang": "^1.0.55",
  "lodash": "^4.17.21",
  "mqtt": "^4.3.7",
+ "nbody": "^0.1.1",
  "os": "^0.1.2",
  "patch-package": "^6.5.1",
  "phaser": "^3.54.0",
@@ -122,7 +123,7 @@
  "save-file": "^2.3.1",
  "source-academy-utils": "^1.0.0",
  "source-academy-wabt": "^1.0.4",
- "three": "^0.162.0",
+ "three": "^0.163.0",
  "tslib": "^2.3.1",
  "uniqid": "^5.4.0",
  "url": "^0.11.3"

src/bundles/nbody/CelestialBody.ts

@@ -0,0 +1,75 @@
+import { CelestialBody, type Vector3 } from 'nbody';
+
+/**
+ * Create a new celestial body.
+ * @param label label of the body.
+ * @param mass mass of the body.
+ * @param position position of the body.
+ * @param velocity velocity of the body.
+ * @param acceleration acceleration of the body.
+ * @returns A new celestial body.
+ * @category Celestial Body
+ */
+export function createCelestialBody(label: string, mass: number, radius?: number, position?: Vector3, velocity?: Vector3, acceleration?: Vector3): CelestialBody {
+ return new CelestialBody(label, mass, radius, position, velocity, acceleration);
+}
+
+/**
+ * Get the label of a celestial body.
+ * @param body The celestial body.
+ * @returns The label of the celestial body.
+ * @category Celestial Body
+ */
+export function getLabel(body: CelestialBody): string {
+ return body.label;
+}
+
+/**
+ * Get the mass of a celestial body.
+ * @param body The celestial body.
+ * @returns The mass of the celestial body.
+ * @category Celestial Body
+ */
+export function getMass(body: CelestialBody): number {
+ return body.mass;
+}
+
+/**
+ * Get the radius of a celestial body.
+ * @param body The celestial body.
+ * @returns The radius of the celestial body.
+ * @category Celestial Body
+ */
+export function getRadius(body: CelestialBody): number {
+ return body.radius;
+}
+
+/**
+ * Get the position of a celestial body.
+ * @param body The celestial body.
+ * @returns The position of the celestial body.
+ * @category Celestial Body
+ */
+export function getPosition(body: CelestialBody): Vector3 {
+ return body.position;
+}
+
+/**
+ * Get the velocity of a celestial body.
+ * @param body The celestial body.
+ * @returns The velocity of the celestial body.
+ * @category Celestial Body
+ */
+export function getVelocity(body: CelestialBody): Vector3 {
+ return body.velocity;
+}
+
+/**
+ * Get the acceleration of a celestial body.
+ * @param body The celestial body.
+ * @returns The acceleration of the celestial body.
+ * @category Celestial Body
+ */
+export function getAcceleration(body: CelestialBody): Vector3 {
+ return body.acceleration;
+}

src/bundles/nbody/Force.ts

@@ -0,0 +1,41 @@
+import { CentripetalForce, CombinedForce, Gravity, type CelestialBody, type Force, type Vector3, LambdaForce } from 'nbody';
+
+/**
+ * Create a force that applies to all bodies using the provided higher order/lambda/arrow/anonymous function.
+ * @param fn A function that takes an array of bodies and returns an array of forces of the same length.
+ * @returns A new lambda force.
+ * @category Forces
+ */
+export function createForce(fn: (bodies: CelestialBody[]) => Vector3[]): Force {
+ return new LambdaForce(fn);
+}
+
+/**
+ * Create a force that applies to all bodies.
+ * @param G The gravitational constant.
+ * @returns A new gravity force.
+ * @category Forces
+ */
+export function createGravity(G?: number): Gravity {
+ return new Gravity(G);
+}
+
+/**
+ * Create a centripetal force that pulls bodies towards a center.
+ * @param center The center of the centripetal force.
+ * @returns A new centripetal force.
+ * @category Forces
+ */
+export function createCentripetalForce(center?: Vector3): CentripetalForce {
+ return new CentripetalForce(center);
+}
+
+/**
+ * Create a combined force that is an additive combination of all the given forces.
+ * @param forces The forces to combine.
+ * @returns A new combined force.
+ * @category Forces
+ */
+export function createCombinedForce(forces: Force[]): CombinedForce {
+ return new CombinedForce(forces);
+}

src/bundles/nbody/Misc.ts

@@ -0,0 +1,14 @@
+import type { CelestialBody, State, Universe, Vector3 } from "nbody";
+
+/**
+ * Deep clone an object.
+ * @param obj The object to clone.
+ * @returns The cloned object.
+ * @category Celestial Body
+ * @category State
+ * @category Universe
+ * @category Vector
+ */
+export function clone(obj: CelestialBody | State | Universe | Vector3): CelestialBody | State | Universe | Vector3 {
+ return obj.clone();
+}

src/bundles/nbody/SimulateFunction.ts

@@ -0,0 +1,52 @@
+import { ExplicitEulerSim, RungeKutta4Sim, SemiImplicitEulerSim, VelocityVerletSim, LambdaSim, type Force, type State, Gravity } from 'nbody';
+
+/**
+ * Create an explicit euler integrator to be used as the simulation function.
+ * @param force The force that applies to the nbody system.
+ * @returns A new explicit Euler simulation.
+ * @category Simulate Functions
+ */
+export function createExplicitEulerSim(force?: Force): ExplicitEulerSim {
+ return new ExplicitEulerSim(force);
+}
+
+/**
+ * Create a numerical integrator that uses the Runge-Kutta 4 method to simulate the nbody system.
+ * @param force The force that applies to the nbody system.
+ * @param weights The weights to be used for the weighted sum of the k values.
+ * @returns A new Runge-Kutta 4 simulation.
+ * @category Simulate Functions
+ */
+export function createRungeKutta4Sim(force?: Force, weights?: number[]): RungeKutta4Sim {
+ return new RungeKutta4Sim(force, weights);
+}
+
+/**
+ * Create a numerical integrator that uses the semi-implicit Euler method to simulate the nbody system.
+ * @param force The force that applies to the nbody system.
+ * @returns A new semi-implicit Euler simulation.
+ * @category Simulate Functions
+ */
+export function createSemiImplicitEulerSim(force?: Force): SemiImplicitEulerSim {
+ return new SemiImplicitEulerSim(force);
+}
+
+/**
+ * Create a numerical integrator that uses the velocity Verlet method to simulate the nbody system.
+ * @param force The force that applies to the nbody system.
+ * @returns A new velocity Verlet simulation.
+ * @category Simulate Functions
+ */
+export function createVelocityVerletSim(force: Force): VelocityVerletSim {
+ return new VelocityVerletSim(force);
+}
+
+/**
+ * Create a simulate function (usually a numerical integrator) that is used to simulate the nbody system using the provided higher order/lambda/arrow/anonymous function.
+ * @param fn The function to be used as the simulate function.
+ * @returns A new lambda simulation.
+ * @category Simulate Functions
+ */
+export function createLambdaSim(fn: (deltaT: number, prevState: State, currState: State) => State): LambdaSim {
+ return new LambdaSim(fn);
+}

src/bundles/nbody/Simulation.ts

@@ -0,0 +1,86 @@
+import context from 'js-slang/context';
+import { RecordingVisualizer, RecordingVisualizer3D, Simulation, type Universe, type VisType } from 'nbody';
+
+/**
+ * Create a new simulation.
+ * @param universes The universes to simulate.
+ * @param visType The visualization type.
+ * @param record Whether to record the simulation.
+ * @param looped Whether to loop the simulation.
+ * @param showTrails Whether to show trails.
+ * @param showDebugInfo Whether to show debug info
+ * @param maxTrailLength The maximum length of trails.
+ * @returns A new simulation.
+ * @category Simulation
+ */
+export function createSimulation(universes: Universe[],
+ visType: VisType,
+ record?: boolean,
+ looped?: boolean,
+ showTrails?: boolean,
+ maxTrailLength?: number): Simulation {
+ return new Simulation(universes, {
+ visType,
+ record,
+ looped,
+ controller: 'code',
+ showTrails,
+ maxTrailLength,
+ });
+}
+
+const simulations: Simulation[] = [];
+const recordInfo = {
+ isRecording: false,
+ recordFor: 0,
+ recordSpeed: 0,
+};
+
+context.moduleContexts.nbody.state = {
+ simulations,
+ recordInfo
+};
+
+function isRecordingBased(sim: Simulation): boolean {
+ return sim.visualizer instanceof RecordingVisualizer || sim.visualizer instanceof RecordingVisualizer3D;
+}
+
+/**
+ * Play a simulation.
+ * @param sim The simulation to play.
+ * @category Simulation
+ */
+export function playSim(sim: Simulation): void {
+ while (simulations.length > 0) {
+ simulations.pop()!.stop();
+ }
+ if (isRecordingBased(sim)) {
+ throw new Error(
+ 'playSim expects non-recording simulations'
+ );
+ }
+ recordInfo.isRecording = false;
+ simulations.push(sim);
+}
+
+/**
+ * Record and play a simulation.
+ * @param sim simulation to record and play.
+ * @param recordFor time to record for.
+ * @param recordSpeed speed to record at.
+ * @category Simulation
+ */
+export function recordSim(sim: Simulation, recordFor: number, recordSpeed: number): void {
+ while (simulations.length > 0) {
+ simulations.pop()!.stop();
+ }
+ if (!isRecordingBased(sim)) {
+ throw new Error(
+ 'recordSim expects recording simulations'
+ );
+ }
+ recordInfo.isRecording = true;
+ recordInfo.recordFor = recordFor;
+ recordInfo.recordSpeed = recordSpeed;
+ simulations.push(sim);
+}

src/bundles/nbody/State.ts

@@ -0,0 +1,21 @@
+import { type CelestialBody, State } from 'nbody';
+
+/**
+ * Create a new state snapshot of the universe.
+ * @param bodies The bodies in the state.
+ * @returns A new state.
+ * @category State
+ */
+export function createState(bodies: CelestialBody[]): State {
+ return new State(bodies);
+}
+
+/**
+ * Get the bodies in a state.
+ * @param state The state.
+ * @returns The bodies in the state.
+ * @category State
+ */
+export function getBodies(state: State): CelestialBody[] {
+ return state.bodies;
+}