Hi Himanshu,
Thanks for the positive feedback on our project approach , really appreciate it!
We've thought through how to divide the work cleanly between us, so here's a breakdown of who's handling what.
Module A: AR Interaction & Rocket Assembly (Piyush Singh)
Piyush is owning everything the user touches before hitting "Launch".
This includes setting up AR surface detection and anchoring using AR Foundation (ARCore/ARKit) so the rocket workspace sits stably on real-world surfaces even as the user moves around. He's building the modular rocket part catalog (nose cones, body tubes, fins, engines, fuel tanks, decouplers) where each part is defined as a ScriptableObject carrying properties like mass, drag coefficient, thrust rating, and fuel capacity.
On top of that, he's implementing a snap-to-fit assembly system with node-based attachment logic. When you drag a part near a compatible connection point, it snaps in with visual feedback (green for valid, red for invalid), and certain rules prevent nonsensical placements like attaching an engine at the top. While you build, the system continuously shows real-time structural data like Center of Mass, Center of Thrust, Thrust-to-Weight Ratio, and symmetry checks, all rendered as AR overlays.
The UI side covers a parts selection panel, gesture controls (tap, drag, rotate, pinch-to-scale), undo/redo, and a pre-launch checklist. He's also integrating Firebase so users can save, load, and share their rocket designs.
Module B: Physics Simulation & Space Flight Engine (Sankalp Pathak)
I'm taking over everything that happens once the rocket leaves the ground.
The core is a flight dynamics engine that simulates thrust, gravity, aerodynamic drag, and torque in real time, with planet-configurable gravity. For numerical stability, I'm using RK4 (Runge-Kutta 4th order) integration at a fixed 60Hz timestep, with rocket mass decreasing as fuel burns.
Failure modes are fully simulated. The rocket will behave realistically if TWR drops below 1, structural stress exceeds limits, misalignment causes tumbling, fuel runs out mid-flight, or it simply hits the ground. Each failure has a corresponding visual effect.
Multi-stage support includes decoupler firing, clean stage detachment as a separate physics object, and upper stage ignition with recalculated mass. For visuals, I'm using GPU-instanced particle systems for engine exhaust, smoke trails, explosions, stage separation bursts, and atmospheric heating, optimized to run smoothly on mobile.
I'm also building trajectory visualization with motion trails, force arrows, velocity/altitude HUD, and orbit prediction for high-altitude flights. Gravity presets will cover Earth (9.81 m/s²), Moon (1.62 m/s²), Mars (3.72 m/s²), and a custom sandbox mode. Finally, a replay and telemetry system will let users play back their flights, view altitude/velocity/fuel graphs, and compare multiple flight runs.
How the two modules connect
The handoff between our two modules happens through a single RocketConfiguration object, a serializable data structure that holds part types, positions, masses, thrust values, fuel capacities, stage definitions, and computed values like total mass, CoM, CoT, and TWR.
When the user presses Launch, Piyush's module generates this object. My module picks it up and runs the simulation from there. This keeps our code largely independent, lets us test and demo our parts separately, and makes integration straightforward.
We've planned two integration checkpoints, one mid-project and one near the end, to make sure the build to launch to simulation flow works end to end.
We're also working on the entry task and will have our demos ready to share soon. Let us know if anything in the architecture needs a rethink or if you'd like more detail on any part.
Thanks,
Sankalp Pathak & Piyush Singh