Click here to return to the main Projects page.

JUMP POINT CALCULATOR APPLICATION

Introduction
The following article is an informal discussion on the formulas for calculating jump points along with why jump points work and how I came up with the formulas. What are jump points? They are a name competitive Pokemon battlers give to what is actually a “bonus point.” Part of competitive battling is working with numbers that are hidden—not obviously in the game—called “Effort Values” (EVs) and “Individual Values” (IVs). These numbers affect a Pokemon’s “stats.” The larger the number a stat is, the better the stat is. IVs cannot change and are set in stone. They range from 0 to 31 and add to a Pokemon’s stat. EVs, on the other hand, can be changed. However, no single Pokemon can have more than 510 EVs total and no more than 255 EVs can be added to a single stat. 4 EVs add one extra point to a Pokemon’s stat (4 EVs = 1 stat point).

Getting back to jump points, an interesting phenomenon occurs when a certain number of EVs are added to a Pokemon’s stat that is boosted by its “nature.” If a nature boosts a stat, it increases the stat by 10% but only after IVs and EVs have been added. A stat which is boosted by a nature is often called a “positive nature” while a stat which is unaffected by a nature is often called a “neutral nature” even though it would be more proper to say “positive nature stat” or “neutral nature stat.”

As stated earlier, after investing 4 EVs, you will get an increase of one stat point. However, if you continue to add 4 EVs to a stat which is boosted by a nature, you will eventually receive an increase of 2 stat points for the usual 4 EVs. You get one extra stat point for the usual amount of EVs put into a stat, and so it is called a “bonus” or “jump” point. All amounts of EVs which cause this are called “jump points,” and this is the sense in which I have used the term in the title and throughout most of the following article, but I do use both senses of the term interchangeably.

There are a few other things to note. The game mechanics of Pokemon round all decimals down. That is the reason why jump points work, as I shall explain. Another is that the jump point formulas I shall list only work for Pokemon at “level 100,” and “level 100” Pokemon are assumed throughout the entire article. (In general, the higher the level, the stronger the Pokemon is relative to a lower level Pokemon. “Level 100” is the highest level that can be achieved without hacking and thus is another game mechanic. “Level xs” refers to the plural of “Pokemon that are at level x.”) The reason for the formulas working only for level 100s is that a Pokemon’s level also affects its stat due to the formula the game uses to calculate a stat.

Obviously, if a stat is affected in some way, it will affect the number of EVs required to hit a bonus point. However, there is little reason to find jump points for other levels since in competitive Pokemon battling, you compete and thus will use whatever will give you the best in stats—which means level 100. (There is such a thing as a “Little Cup” which uses level 5 Pokemon, but it is definitely not as popular as using level 100s.)

Also, note that only for level 100s do IVs and EVs add directly to a stat—once again because of the formula for calculating a stat. Finally, a Pokemon’s “base stat” is a very important factor in determining a Pokemon’s final stat. Base stats and stats are related by the following equation: 1 base stat point = 2 stat points. A “base of x” or simply “base x” is a Pokemon that has a base stat of x in a certain stat (“base xs” is a common plural form). For level 100s, a base stat of 0 = 36 stat points with a neutral nature, 31 IVs, and 0 EVs. For Pokemon of all levels, a base stat of 0 = 5 stat points with a neutral nature, 0 IVs, and 0 EVs. A common base stat to remember for level 100s is a base stat of 100 = 236 stat points with a neutral nature, 31 IVs, and 0 EVs. The last three equations are true for all stats which are not the specific stat called “Hit Points” (HP) because the stat formula for HP is different from the one used to calculate other stats. (Notice that base stats add directly to the stat for level 100s just like EVs and IVs.)

Original Jump Point formulas
I have three forms of these formulas: the special and first case I found in which the IV of a Pokemon is assumed to be 31; the more generalized case which takes IVs into account but is tedious to use; and the even more tedious to use but great for programming generalized case that takes IVs into account. Here are the original formulas I found:

For base stats ending in 3 or 8, Tn = -8 + 40n

For base stats ending in 4 or 9, Tn = -16 + 40n

For base stats ending in 0 or 5, Tn = -24 + 40n

For base stats ending in 1 or 6, Tn = -32 + 40n

For base stats ending in 2 or 7, Tn = -40 + 40n

Tn = the EVs required for a ‘jump point,’ all Tn’s are in the range [0, 248], and n is an integer ≥ 1.

Jump Point explanation

Jump Points work because of the Pokemon game’s mechanics. They work because the game rounds everything down while natures boost a stat by 10%. To achieve a Jump Point, you make your stat points end in a 0 by using EVs to add to the neutral stat. EVs and IVs add to the neutral stat of a Pokemon. The boost or drop of a nature takes place after the EVs and IVs are added to the neutral stat.

For some explanation why jump points work the way they do, remember how integers work and what happens when you multiply by the 1.1 of a boosting nature. The simple and quick way of explaining this is considering that the game rounds everything down. For all numbers that are not multiples of ten, this results in a decimal which is lost to the game’s rounding. This means that for every stat point you add, your stat point increases by 1. However, when the stat point is a multiple of ten, multiplying by 1.1 will have no decimal.

This means nothing is lost when rounding down, and so you get a bonus. This bonus is equal to one point because the game would round it down if it was a decimal, and 1 is the nearest non-decimal you can get if you increase from 0. (Perhaps more intuitively: 1.1 * 10 = 11 = 10 + 1) So, you get an extra point for the point you put in because that point made the number equal to a multiple of ten.

Here’s the longer but still informal explanation. Integers are the assumed domain for the variables of the following discussion.

What you are doing with a boosting nature is adding one and a tenth of an integer to itself: 1.1X = X + (1/10)X. Now, looking at that equation, you can see that there will be something left over in all cases. However, due to the game always rounding the decimal (fractional part) down, the (1/10)X term will disappear for certain cases. So, the game sees the equation like this: floor (1.1X) = floor (X + (1/10)X) = X + floor ((1/10)X). (That last rearrangement is possible because X is an integer and thus floor (X) = X for all X). Because the game rounds down, 1.1X = X in all cases where (1/10)X is less than 1 because the floor function will make the second term of the equation 0.

Now consider the case in which X makes (1/10)X greater than or equal to one. Let X = Z, where Z makes (1/10)X >= 1. Consider what happens when (1/10)Z = an integer. In that case, Z = 10*an integer, which is another way to say Z is a multiple of ten and thus an integer too. When this happens: P = floor (1.1Z) = Z + floor (integer) = Z + integer. That means for a value of X that is a multiple of ten, X increases by an integer amount when multiplied by 1.1.

Notice this is true for all integers X that make the argument greater than or equal to one, not just values of X which make the argument an integer. However, if (1/10)X >= 1 is not an integer, letting X = Y where Y has this property, then T = floor (1.1Y) = Y + floor(((1/10)Y – fraction) + fraction) = Y + ((1/10)Y – fraction) + floor(fraction) = Y + (1/10)Y – fraction with fraction < 1 being the minimum amount necessary to subtract from (1/10)Y to make (1/10)Y an integer. Precisely how large is this integer that is added in either case? It depends on how large X is. However, we are talking about jump points--points that result from an increase in X--rather than how large the boost from a nature is, which results from the magnitude of X. So we need only know relative change. P = Z + integer = Z + (1/10)Z while T = Y + ((1/10)Y - fraction). P/Z = 1.1, so Z increased by a factor of 1.1 exactly. T/Y = 1.1 - (fraction/Y), so Y increased by a factor of 1.1 - (fraction/Y). Since Y is an integer, fraction/Y = another fraction. This means P/Z > T/Y which means P increased more than T, and so a jump point only occurs when X is a multiple of ten.

And here’s a more mathematically convincing argument for both the above as well as why the bonus point must equal one. Let’s say C is a nonnegative integer, and X = 10C – 2. In other words, some number X is two less than a multiple of ten. If this number X is a stat value in a boosting nature, then the stat is S = floor (1.1(10C – 2)) = 10C – 2 + floor ( .1(10C – 2)) = 10C – 2 + floor (C – .2) = 10C – 2 + C -1 = 11C – 3. Adding 4 EVs = 1 stat point to X gives: F = floor (1.1(10C-1)) = 10C – 1 + floor (.1(10C – 1)) = 10C – 1 + floor (C – .1) = 10C – 1 + C – 1 = 11C – 2 = S + 1. So adding one stat point resulted in an increase of one stat point.

Now watch what happens when I add another stat point–one which makes the stat equal to a multiple of ten. floor (1.1(10C)) = 10C + floor (.1(10C)) = 10C + C = 11C = F + 2 = (F + 1) + 1. Notice that this is two more stat points than F. I added one stat point and got an increase of two stat points. Since C can be any nonnegative integer–which means 10C can be any nonnegative multiple of ten–just like a stat that is a multiple of ten–the above shows the bonus point, i.e. the jump point, must equal one and only occurs at multiples of ten in a neutral stat given the properties of the game’s mechanics.

The other forms of the Jump Point formulas

The new, generalized formulas for calculating any ‘jump points’ mathematically:

For base stats ending in 3 or 8, Tn = 36 – 4I + 40n

For base stats ending in 4 or 9, Tn = 28 – 4I + 40n

For base stats ending in 0 or 5, Tn = 20 – 4I + 40n

For base stats ending in 1 or 6, Tn = 12 – 4I + 40n

For base stats ending in 2 or 7, Tn = 4 – 4I + 40n

Tn = the EVs required for a ‘jump point,’ all Tn’s are in the range [0, 252], n is an integer ≥ 0, and I = your IV.

—————————————————————————————————————————–

And here’s their counterpart, the “programmable form.” They’re more complicated but reduce back to the original formulas for I = 31, unlike the above ones (albeit, with n ≥ 0):

For base stats ending in 3 or 8, Tn = 36 – 4I + 40*int (|36 – 4I|/40) + 40n

For base stats edning in 4 or 9, Tn = 28 – 4I + 40*int (|28 – 4I|/40) + 40n

For base stats ending in 0 or 5, Tn = 20 – 4I + 40*int (|20 – 4I|/40) + 40n

For base stats ending in 1 or 6, Tn = 12 – 4I + 40*int (|12 – 4I|/40) + 40n

For base stats ending in 2 or 7, Tn = 4 – 4I + 40*int (|4 – 4I|)/40) + 40n

Tn = the EVs required for a ‘jump point,’ all Tn’s are in the range [0, 252], n is an integer ≥ 0, int (x) is the greatest integer function, and I = your IV.

How I found the Jump point formulas
Part 1

One day, I decided to see if I could find a formula to calculate the jump point EVs to make them easier to remember. As I looked at them carefully, I suddenly noticed something I had not noticed before: the jump point EVs were exactly 40 EVs apart.

Fortunately, I had just worked with sequences and series in my Algebra II/Trig course, so this was a simple matter. It was obviously an arithmetic sequence with a common difference of 40. All I needed then was the first term. After thinking about it for a while, I decided to divide the jump point EVs by four and add them to the base stat for 100s because I had memorized the stats for base 100s. I noticed that they were all multiple of tens. I had an “Aha!” moment and got to work on finding my first term for my arithmetic sequence. I remembered that a Pokemon with 31 IVs and no EVs had a stat of 236 for neutral base 100s.

I decided to start with no EVs for obvious reasons. I stayed with 31 IVs because that is what everyone used, which meant the thought never occurred to me to make a formula which took those into account. I was merely trying to fit an arithmetic sequence to the jump points I had seen on the internet.

I noticed that 236 was four away from 240. After trying and failing by using a first term of four, I remembered that 4 EVs = 1 stat point. That meant in stat points, the common difference was ten. If I then multiplied the equation by four, I would have a sequence for the jump point EVs. And so, I came up with the following formula: Tn = 4 * (4 + (10 * (n -1))). Thrilled by my discovery, I tried applying it to other bases. However, I soon found out that they did not work. Working a while, I found a different sequence for base 77s. I then found different, unique sequences for base 105s, 106s, 108s, 109s, and 105s. I noticed that the sequence was the same for base 105s and 100s.

When I got to my computer, I racked my brain trying to figure out why the jump point EVs I had seen would not work for other bases, i.e. why the bases had different sequences except for base 105s and 100s. To help me see more clearly, I simplified the expression to Tn = -24 + 40n. I simplified the one for base 77s: Tn = -40 + 40n. The same form! I soon simplified the rest. They all had the same form! Not to mention that all the first terms had a difference of 8 between them in a pseudo-cyclical pattern. I say “pseudo-cyclical” because adding 8 to the first terms does not eventually cause them to repeat a first term. However, since adding 8 enough times is the same as adding a multiple of 40, the sequences themselves would reappear again, albeit starting later in the sequence. I also noticed that any single formula worked for two bases that were 5 base stat points apart.

I stared at the expressions for a bit then realized 40 EVs = 10 stat points! Of course! The jump points worked because they are multiples of ten. Adding ten to ten is another multiple of ten. This meant that each base had different sequences because of different first terms. That each formula worked for two base stats which were separated by 5 base stat points made sense since 5 base stat points = 5*2 Stat points = 10 Stat points = another multiple of ten. And that also meant that the jump point only depended on the last digit of the base stat (adding 5 is adding ten base stat points and uses the same formula; adding 10 is adding 20 base stat points; either case is another multiple of ten). So, the five formulas I now had were completely sufficient for calculating any jump point EVs for any base. I pretty much ignored IVs at this point since less than 31 IVs in a stat is generally rare.

Part 2

Or so I thought. When I posted my jump points originally, I thought I had made it clear that they only worked for an IV of 31. I thought nothing more of it until someone mentioned something about my formulas and asking whether IVs affected jump points. This got me thinking, and after much work, I eventually generalized my formulas, after which I generalized them again so that they reduced back to my original equations for I = 31 (albeit for n = 0 instead of n = 1 as a starting n).

To take IVs into account, I’d simply just need to add the difference between the perfect IV and the actual IV in EV points to the original formulas. This is because a less than perfect stat will need that many more stat points to get to the same jump point with a perfect IV. For example, 236 is the neutral, minimum stat for base 100s. However, if the Pokemon had only 18 IVs, then the neutral, minimum stat would be 236 – how far away the IV is from 31. Mathematically, this becomes 236 – (31 – 18) = 236 – 31 + 18 = 223. Notice that it is 7 stat points from reaching its first jump point and that it is 17 stat points from reaching what is the first jump point for a perfect IV. It would need 4*7 = 28 EVs for the first jump point and 4*17 = 68 IVs to reach the perfect IV first jump point.

Because my original formulas took this into account already so that no jump points would be missed, all that needed to be done was to add 4 times this difference to each formula (the original formulas are in EV points, remember). Doing this for the base 100 stat gives Tn = -24 + 40n + 4(31 – I) = -24 + 40n + 124 – 4I = 100 – 4I + 40n, n >= 1. The derivations of the others are similar.

For a little experimental evidence, here is a test to see if it gets that first jump point for I = 18: 100 – (4*18) = 28. And as you can easily see, it gets the second jump point too. It doesn’t miss any of them. Of course, because of the way imperfect IVs fall, the EVs can now range from 0 to 252 inclusive, so the range needs to be adjusted for this, which I did do.

However, on closer inspection you can see that the formulas don’t always work and sometimes miss some jump points. Notice also, that the example I just gave is flawed: it assumed n ≥ 0, not n ≥ 1 like the formula says for catching the first jump point. Why is this? It’s because the first jump point must always be less than or equal to 40. Assuming n ≥ 0, you can see that the example catches the first jump point because for n = 0, the number is 28 which is less than or equal to 40. That was why my original jump point formulas didn’t miss any points earlier on.

So, to remedy this, I just needed to make the sequence so that for I = 0 (which results in the greatest number added to 40n) the number added to 40n would be less than or equal to 40 for n ≥ 0, or the number added to 40n would be less than or equal to 40 in magnitude for n ≥ 1, which is the same as the other since both include the same sequence of jump points. To make the formulas similar to the originals, the latter is what I aimed for.

Looking at Tn = 100 – 4I + 40n, you can see that for I = 0, Tn = 100 + 40n. To keep the sequence the same while changing its form to make the first term <= 40, I divided 100 by 40 (this results in a subsequence of the original because the “period” is 40) and got 2.5. Half of 40 is 20 which means the remainder is 20, so this means that now Tn = 20 + 40n for n ≥ 0--an equivalent sequence to the above in that it produces the same jump point numbers eventually. The first jump point is Tn = 20, so to shift this formula to work for n ≥ 1, I simply changed it to Tn = -20 + 40n which gives the first number 20 like the other one. You can verify this is accurate by checking a 0 IV base 100. Its minimum, neutral stat is 205 which requires 20 EVs (5 stat points) to reach the first jump point. The math is a little messier for larger IVs now (eg., you have to add 40 four times in order to get your first valid jump point if you use 31 IVs), but because of the range restriction, these formulas still work fine and consistently. You do get your first valid jump point computationally quicker if you go with the n ≥ 0 formula though. So, I switched them to that form despite my original goal. The rest were derived in a similar manner. Part 3
While I had successfully generalized my jump point formulas to take IVs into account, I was quite annoyed at their tediousness. Some didn’t reveal an actual jump point until the third or fourth term! So, I decided to program them into a computer. To do this though without having a lot of messy code, I needed to write these formulas in yet another form to make them consistent and efficient for computation and clean-looking. I was also annoyed that my new generalized formulas didn’t reduce back to my original ones. So I also needed them to reduce back for I = 31. I could ignore the “40n” term, since all that “mattered” was the first jump point term.

All that I needed to do was to shift these formulas over. I could do this by using a specific starting “n,” or I could add a positive term to each of the formulas to cancel out the negative terms and so keep the same starting “n.” How big would this term be though? It would need to be a variable term and need to cancel out the most negative the first term could get. Starting with the formula for bases ending in 5 or zero, I plugged I = 31 into my formula: 20 – 4(31) = 20 – 124 = -104. The first jump point appeared after adding 3 * 40 = 120. I also noticed that adding 2 * 40 = 80 would make the formula reduce to my original formula.

So what I wanted to do was find a way to add a positive number so that the negative first term canceled just short of the first jump point, which meant it needed to be a negative number (negative, so I could use n>=1 like with my original formulas). I needed to find how many times 40 went into the negative number and add an appropriate number of 40s with that information. |-104/40| = 2.6. If I rounded this down, it would be the number of 40s I was looking for. Remember that -104 = 20 – 4(31). So in general, the number to be divided by 40 would be |20 – 4I|. To round the number down, I could use a number of functions, but I decided to use the greatest integer function because I like its definition, and it is available on many languages since it is a mathematical function.

So the number of times I would need 40 to go into 20 – 4I would be int(|20 – 4I|/40). Now, I don’t remember what I did next, but I needed to multiply that last expression by 40 in order to get it to add properly to the number. This makes sense since the quotient inside the function’s argument would get the integer number of times that 40 went into 20 – 4I. Multiplying the function by 40 then would get a number which when added to 20 – 4I would leave the remainder: the negative number which I was looking for. This number is also obviously less than 40 in magnitude, so adding one more 40 would produce the first jump point, and better still, this negative number is the same one as in my original formulas for I = 31: -24.

Let P(x) > 0 be the dividend, R(x) > 0 be the remainder, Q(x) > 0 be the quotient, and D(x) > 0 the divisor. The answer then is of the form -P(x)/D(x) = -Q(x) – R(x)/D(x). Since D(x) = 40, this makes it: -P(x)/40 = -Q(x) + -R(x)/40 –> -P(x) = -40*Q(x) – R(x). Solving for -R(x) gives: -R(x) = -P(x) + 40*Q(x). And so as you can see, multiplying by 40 gives me the number I am looking for. The formulation of the rest of the formulas is similar. I left it with n = 0 despite my original goal and the one extra 40 that must be added in certain cases because otherwise, the formulas would miss some jump points for certain values of I. Indeed, with n = 1, they miss the number 0 as a valid jump point and skips to 40 for certain combinations of bases and IVs. A simple decision structure takes care of this negative number starting point in a computer program easily.