Skip to content

EVE Developer Documentation

Crowdsourced documentation for third-party developers

Other

Useful Formulae

Warp-in points

Ordinary Objects

An ordinary object is any object that does not fall withing any of the other categories described below.

Let the 3D vectors \(p_d\) and \(p_s\) represent the object’s position and the warp’s origin, respectively; and \(\vec{v}\) the directional vector from \(p_s\) to \(p_d\). Let \(r\) be the object’s radius.

The object’s warp-in point is the vector \(p_s + \vec{v} - r\hat{v}\).

In other words, the warping ship arrives at a point between the starting position and the targets' position, at the edge of the targets' radius.

Large Objects

A large object is any Celestial (type category 2) with a radius of at least 90 kilometres (180 kilometres in diameter), except wrecks, planets, and suns.

Let \(x\), \(y\), and \(z\) represent the object’s coordinates. Let \(r\) be the object’s radius.

The object’s warp-in point is the vector \(\left(x + (r + 5000000)\cos{r} \\, y + 1.3r - 7500 \\, z - (r + 5000000)\sin{r} \\ \right).\)

Example

import kotlin.math.*

fun getLargeObjectWarpInPoint(x: Double, y: Double, z: Double, radius: Double): Triple<Double, Double, Double> {
    val x = (radius + 5000000) * cos(radius)
    val y = 1.3 * radius - 7500
    val z = -(radius + 5000000) * sin(radius)
    return Triple(x, y, z)
}

Suns

The warp-in point of a sun is determined by its radius.

Let \(r\) be the sun's radius.

The sun’s warp-in point is the vector \(\left((r + 100000)\cos{r} \\, 0.2r \\, -(r + 100000)\sin{r} \\ \right).\)

Example

import kotlin.math.*

fun getSunWarpInPoint(radius: Double): Triple<Double, Double, Double> {
    val x = (radius + 100000) * cos(radius)
    val y = 0.2 * radius
    val z = -(radius + 100000) * sin(radius)
    return Triple(x, y, z)
}

Planets

The warp-in point of a planet is determined by the planet's ID, its location, and radius.

Let \(x\), \(y\), and \(z\) represent the planet's coordinates. Let \(r\) be the planet's radius, and \(p\) be the planet's ID.

The planet's warp-in point is the vector \(\left(x + d \sin{\theta}, y + \frac{1}{2} r \sin{j}, z - d \cos{\theta}\right)\) where:

\[ d = r(s + 1) + 10^6 \]
\[ \theta = \sin^{-1}\left(\frac{x}{|x|} \cdot \frac{z}{\sqrt{x^2 + z^2}}\right) + j \]
\[ s|_{0.5 \leq s \leq 10.5} = 20\left(\frac{1}{40}\left(10\log_{10}\left(\frac{r}{10^6}\right) - 39\right)\right)^{20} + \frac{1}{2} \]
\[ j = \frac{mt(p) - 1}{3} \]

The function \(mt(p)\) represents the first floating point number in range \([0,1)\) generated by a Mersenne Twister PRNG seeded with the planet's ID.

In Python, this is equivalent to random.Random(p).random(). Implementations of Mersenne Twisters are widely available for popular languages, but you need to be careful to match Python's, as not all implementations use the provided seed in the same way.

Example

import org.apache.commons.math3.random.MersenneTwister
import kotlin.math.*

fun getPlanetWarpInPoint(planetId: Int, x: Double, y: Double, z: Double, radius: Double): Triple<Double, Double, Double> {
    val j = (MersenneTwister(intArrayOf(planetId)).nextDouble() - 1) / 3
    val theta = asin((x / abs(x)) * (z / (sqrt(x.pow(2) + z.pow(2))))) + j
    val s = (20 * ((10 * log10(radius / 1000000) - 39) / 40).pow(20) + 0.5).coerceIn(0.5, 10.5)
    val d = radius * (s + 1) + 1000000
    return Triple(x + sin(theta) * d, y + radius * sin(j) / 2, z - cos(theta) * d)
}

import math
import random


def warpin(id, x, y, z, r):
    j = (random.Random(id).random() - 1.0) / 3.0
    t = math.asin(x / abs(x) * (z / math.sqrt(x**2 + z**2))) + j
    s = 20.0 * (1.0 / 40.0 * (10 * math.log10(r / 10**6) - 39)) ** 20.0 + 1.0 / 2.0
    s = max(0.5, min(s, 10.5))
    d = r * (s + 1) + 1000000

    return (x + d * math.sin(t), y + 1.0 / 2.0 * r * math.sin(j), z - d * math.cos(t))

Skillpoints needed per level

The skillpoints needed for a level depend on the skill rank.

\(y_{skillpoints} = 2^{2.5(x_{skilllevel}-1)} \cdot 250 \cdot r_{skillrank}\)

Skillpoints for common ranks

Rank Level 1 Level 2 Level 3 Level 4 Level 5
1 250 1.414 8000 45,254 256,000
2 500 2,828 16,000 90,509 512,000
3 750 4,242 24,000 135,764 768,000
4 1000 5,656 32,000 181,019 1,024,000
5 1250 7,071 40,000 226,274 1,280,000
6 1500 8,485 48,000 271,529 1,536,000
7 1750 9,899 56,000 316,784 1,792,000
8 2000 11,313 64,000 362,039 2,048,000
9 2250 12,727 72,000 407,293 2,304,000
10 2500 14,142 80,000 452,548 2,560,000
11 2750 15,556 88,000 497,803 2,816,000
12 3000 16,970 96,000 543,058 3,072,000
13 3250 18,384 104,000 588,312 3,328,000
14 3500 19,798 112,000 633,567 3,584,000
15 3750 21,213 120,000 678,822 3,840,000
16 4000 22,627 128,000 724,077 4,096,000

Skillpoints per minute

The skillpoints generated each minute depend on the primary \((a_{primary})\) and secondary attribute \((a_{secondary})\) of the skill.

\[ y_{skillpointsPerMinute} = a_{primary} + {a_{secondary} \over 2} \]

Target lock time

The target lock time (\(t_{targetlock}\)) in seconds depends on the ship's scan resolution (\(s\)) and the target's signature radius (\(r\))

\[ t_{targetlock} = {40000 \over s \cdot asinh(r)^2} \]

Alignment time

The ship alignment time (\(t_{align}\)) depends on the ship's inertia modifier (\(i\)) and the ships mass (\(m\))

\[ t_{align} = { ln(2) \cdot i \cdot m \over 500000 } \]