A web application built with Next.js to calculate the optimal time and location to jump from the Fortnite Battle Bus to reach a desired landing spot in the minimum amount of time.
- Overview
- Features
- Screenshots
- How it Works (The Math)
- Technology Stack
- Getting Started
- Usage
- Configuration
- Contributing
- License
In battle royale games like Fortnite, reaching your desired landing spot quickly and efficiently can provide a significant advantage. This project aims to solve the problem of finding the mathematically optimal point to jump from the Battle Bus.
Given a specific Battle Bus path and a desired landing location on the map, this tool calculates:
- Optimal Jump Point (Red Dot): The precise point along the bus path where the player should jump off.
- Aim Point (Green Dot): The point on the ground the player should aim towards during the initial dive phase to ensure the glider deploys correctly for the final approach.
The calculation minimizes the total travel time, which is the sum of the time spent riding the bus and the time spent flying (diving and gliding).
- Visual representation of the Fortnite map.
- Ability to define or display the Battle Bus path.
- Interactive selection of the desired landing location (Target Point).
- Calculation and display of the Optimal Jump Point (Red Dot) on the bus path.
- Calculation and display of the Aim Point (Green Dot) on the flight path.
- Visualization of the calculated flight path (dive + glide segments).
- Displays calculated metrics like estimated flight time and jump angle relative to the bus path.
- Uses a physics-based model for player flight.
Add your screenshots here to showcase the application.
Main Interface:
Example Calculation:
(Caption: Example calculation showing the optimal jump point (Red) and aim point (Green) for landing at Brutal Boxcars)
The core of the application is a physics simulation based on Fortnite's movement mechanics. The goal is to find a Jump Point J on the bus path that allows the player to reach the Target T while minimizing time_on_bus + time_in_air. Since time_in_air for an optimal flight path from any jump point to the target is constant (assuming the target is reachable), minimizing total time means minimizing time_on_bus. This translates to finding the earliest point on the bus path from which the target is reachable.
The simulation relies on the following constants (which can be configured):
// --- FORTNITE PHYSICS CONSTANTS ---
const BUS_SPEED = 100; // Bus speed (m/s)
const H_BUS = 830; // Height in bus (m)
const H_JUMP = 810; // Height right after jump (m)
const H_FORCE_DEPLOY = 100; // Forced deploy height above ground (m)
const V_DIVE_VERTICAL = 60; // Max vertical dive speed (m/s)
const V_DIVE_HORIZONTAL = 30; // Horizontal speed during dive (m/s)
const V_GLIDE_HORIZONTAL = 32; // Horizontal glide speed (m/s)
const V_GLIDE_VERTICAL = 12; // Vertical glide descent speed (m/s)
const FORTNITE_MAP_WIDTH_METERS = 3500; // Approx map width (m)
const FORTNITE_MAP_HEIGHT_METERS = 3500; // Approx map height (m)
// Assumes target landing ground height H_GROUND = 0mDive Phase:
Vertical distance: ΔH_dive = H_JUMP - H_FORCE_DEPLOY = 810m - 100m = 710m
Dive time: t_dive = ΔH_dive / V_DIVE_VERTICAL = 710m / 60m/s ≈ 11.83s
Horizontal distance covered during dive: d_dive_horizontal = t_dive * V_DIVE_HORIZONTAL ≈ 11.83s * 30m/s ≈ 355m
Glide Phase:
Vertical distance: ΔH_glide = H_FORCE_DEPLOY - H_GROUND = 100m - 0m = 100m
Glide time: t_glide = ΔH_glide / V_GLIDE_VERTICAL = 100m / 12m/s ≈ 8.33s
Horizontal distance covered during glide: d_glide_horizontal = t_glide * V_GLIDE_HORIZONTAL ≈ 8.33s * 32m/s ≈ 266.7m
Total Flight:
Total flight time: t_flight = t_dive + t_glide ≈ 11.83s + 8.33s ≈ 20.16s
Total horizontal distance covered from jump to landing: d_flight_total = d_dive_horizontal + d_glide_horizontal ≈ 355m + 266.7m ≈ 621.7mThe player needs to jump when they are exactly d_flight_total (approx 622m) horizontal distance away from the target landing spot T.
Represent the bus path as a line segment (defined by its start and end points).
Represent the target location T as a point (Tx, Ty).
Mathematically, we find the intersection point(s) of the bus path line and a circle centered at T with a radius of d_flight_total.
If there are two intersection points on the bus path segment, the optimal jump point J (Red Dot) is the one the bus reaches first (i.e., the one closer to the bus path's starting point).
If there is only one intersection point (tangent) or no intersection, the target might be unreachable directly from the bus path with this flight model, or the jump point is at the very start/end of the relevant path segment.
The Green Dot represents the ground location directly below where the glider automatically deploys (H_FORCE_DEPLOY). It's where the player should aim during the dive phase.
Calculate the vector V_JT from the Optimal Jump Point J = (Jx, Jy) to the Target T = (Tx, Ty).
Calculate the unit vector (direction) U_JT = V_JT / |V_JT|.
The Aim Point A (Green Dot) is found by moving d_dive_horizontal meters from the Jump Point J in the direction U_JT: A = J + d_dive_horizontal * U_JT
Ax = Jx + d_dive_horizontal * (Tx - Jx) / |V_JT|
Ay = Jy + d_dive_horizontal * (Ty - Jy) / |V_JT|
(Note: This requires converting map coordinates (pixels) to simulation coordinates (meters) and back, using the map dimensions like FORTNITE_MAP_WIDTH_METERS).
Framework: Next.js - React framework for production.
Language: TypeScript - For type safety.
UI Library: React
Styling: Tailwind CSS
State Management: Caching
Map Rendering: FortniteAPI
Node.js (Version >= 18.x recommended)
npm or yarn
git clone https://github.com/brezys/DropMap cd DropMap
cd my-fortnite-planner npm install
yarn install
(Optional) Set up environment variables if needed. Create a .env.local file by copying .env.example (if you provide one) and fill in the required values.
cp .env.example .env.local
npm run dev
yarn dev
Open http://localhost:3000 with your browser to see the application.
Navigate to the application in your web browser.
The Fortnite map should be displayed.
Click on the map to select your desired landing spot (Target Point T).
Click to input the starting point for the bus followed by the ending point.
The application will automatically calculate and display:
The Optimal Jump Point (Red Dot) on the bus path.
The Aim Point (Green Dot).
The projected flight path line.
Relevant data like estimated flight time and jump angle.
The core physics constants can be adjusted within the source code, typically in a dedicated constants file (e.g., app/lib/geometry.ts).
// Example: app/lib/geometry.ts const BUS_SPEED = 135; // Bus speed (m/s) const H_BUS = 830; // Height in bus (m) const H_JUMP = 810; // Height right after jump (m) const H_FORCE_DEPLOY = 100; // Forced deploy height above ground (m) const V_DIVE_VERTICAL = 60; // Max vertical dive speed (m/s) const V_DIVE_HORIZONTAL = 42; // Horizontal speed during dive (m/s) const V_GLIDE_HORIZONTAL = 32; // Horizontal glide speed (m/s) const V_GLIDE_VERTICAL = 12; // Vertical glide descent speed (m/s)
// Simulation parameters const SIMULATION_TIME_STEP = 0.1; // Time step for physics simulation (seconds) const NUM_BUS_PATH_STEPS = 150; // Number of points to check along the bus path
// Map dimensions in meters (estimated from Fortnite's actual map) const FORTNITE_MAP_WIDTH_METERS = 3800; // Approximate width of Fortnite map in meters const FORTNITE_MAP_HEIGHT_METERS = 3800; // Approximate height of Fortnite map in meters
Contributions are welcome! Please feel free to submit pull requests or open issues to improve the calculator.
This project is licensed under the MIT License.