T w e n t y S i d e d

The Borderlands games have this thing called “Badass ranks”. It’s this sort of meta-leveling system that’s not tied to any specific character, but is instead based on some global stateActually, in the first one it works a little different, but whatever. For now let’s focus on the Borderlands 2 and Pre-Sequel.. You complete goals, the goals give you badass points, the points fill a leveling bar, and when it fills up you get a single badass token. These tokens can be spent on really, really small upgrades like “Plus a tenth of a percent more damage with guns”. But these upgrades apply to all your characters, now and in the future.

The goals are typical achievement-bait type stuff: Kill X people with fire damage. Open X loot chests. Loot X items of a given rarity. Sell X items. Kill X of creature Y with melee attacks. Get X headshots. Do X sidequests. Deal X points of damage with weapon Y. And so on.

This is Athena from Pre-Sequel. (Best character.) The bonus stats you see on the left apply to all the characters I create. The game lets you disable these if you want, presumably to allow serious players to set up “fair” duels.

There are numerous goals, to the point where you’ll be hitting new ones every couple of minutes. If you’re looking to maximize the number of badass tokens you earn, then it’s best to avoid getting stuck in a rut with one favorite character, weapon, and playstyle. Use all the weapons, fight all the foes, use vehicles, use melee, and generally mix things up.

There’s no limit on how many badass tokens you can earn, although they do become harder (slower) to earn over time. This means that your first character will always be your weakest. If you go through the game with multiple characters and earn tons of tokens, then later on your characters will have all these bonuses that weren’t available to you the first time you fired up the game.

The bonuses are small, but they stack and they impact nearly every aspect of your character. An extra one percent gun damage is nothing. But what if you’re shooting one percent faster, hitting one percent more accurately, getting one percent more criticals, have one percent more health, AND doing one percent more damage? That’s probably still a minor advantage, but I’m betting that by the time you’ve got a 5% to all your stats you’re a lot more than just “5% stronger”.

Maya from Borderlands 2. Here you can see I get to choose from five possible bonuses: Elemental Effect CHANCE, Melee Damage, Critical Hit Damage, Elemental Effect Damage, and Gun Accuracy. (These probably yield a tenth of a percent bonus.) Below that you can see the sum of all the bonuses I’ve unlocked so far.

It’s also worth noting that you can’t directly control what stats get boosted. When you go to spend a token on upgrades, you have to choose ONE of five options out of the dozens of possible stats. So if you start pouring everything into (say) shields, the game will stop offering shields as one of the possible upgrades until you put some points in elsewhere. It’s basically a system designed to blunt attempts at min-maxing.

In any case, the upgrades make you stronger. But… how much stronger? That’s a really complex question. Short of looking at the Borderlands game code there’s no way to be sure. But I decided to write a little program to simulate combat to see how much of a benefit “5% to everything” might be.

This all happens in a terminal window, no graphics. (Sorry.) We’re simulating two evenly-matched combatants. The two characters shoot at each other. The moment one drops dead, the victim instantly respawns with full health and a reloaded weapon. We keep track of kills and the simulation ends after 1,000 deaths.

(Upon reflection, it might have been better to have two theoretical players gun down NPC mooks over a fixed period of time, and score them based on who slaughtered the most mooks.)

Axton kinda ruined the game for me. His special power was a turret with massive hitpoints and good damage output that instantly grabbed all aggro. It was basically a “get out of dying, free” button. It felt far more powerful than the other special abilities, but was also kinda boring to use.

As all projects, this one get quickly mired in vexing questions that weren’t obvious at first:

1. What kind of weapons are we simulating? In a Borderlands shotgun fight, the guns do MASSIVE (possibly insta-kill) damage but take ages to reload. If we’re using an SMG, then the bullets do tiny damage. With one weapon the bonus damage is meaningless (since every hit is a kill) while the other weapon magnifies the importance of bonus damage.
2. In Borderlands, weapons have this accuracy stat that controls how wide their cone of possible bullet trajectories is. This is supremely important in a sniper rifle battle at long distances, and completely worthless if we’re using rockets at point-blank range.
3. If fights are high damage then bonuses to reload speeds and magazine sizes are useless, since combatants will drop dead long before they empty their weapon.
4. How does a bonus to “refire rate” work? If a weapon had 100% bonus to fire rate, would that make it shoot twice as fast, or would that reduce the cooldown to zero, effectively making a weapon that should fire “infinitely” fast? I’ll assume the former, since the latter just makes no sense. However, there’s no telling what’s going on under the hood in Borderlands. The tooltips were designed for brevity and simplicity, not precision. They exist so you can eyeball the difference between two items at a glance.

Basically, this test is meaningless because I can coerce any result I want. I can set up a fight where 5% bonus can change the entire outcome or I can set up a fight where the 5% bonus does almost nothing.

I try to split the difference and make sure all stats are useful. We’ll assume a fight at medium distance with a low damage weapon with a moderate rate of fire.

Gaige from Borderlands 2. You can see I’ll earn a Badass rank for killing ten midgets. The next tier will probably unlock at something like 100 midgets, then 1000, etc.

I’ve got two combatants, which for the purposes of this exercise I’ve named “Player” and “Mook”. With no bonus, they each have 100 hitpoints, have a 25% chance to hit, their guns fire every 100 time-unitsGeneric time units. Not mapped to real-world time in any meaningful way. I don’t want to actually sit here and wait ten minutes for the contest to play out. and deal 15 damage. Their default guns hold 20 bullets and take 500 time units to reloadEffectively making you miss out on five shots every time you reload..

This isn’t simulating a player duel, because those things happen one at a time and not back-to-back. And we’re not simulating a fight between players and foes, because those aren’t evenly matched. Instead we’re trying to measure the strength of a boosted player against the strength of an un-boosted player. We’re not going to mess around with stuff like shields, melee attacks, grenades, and elemental damage. So don’t think of this as “simulated Borderlands”. It’s more an abstract test to see how powerful it is to have a small percent boost across all stats in a game like Borderlands.

The result? Really unsatisfying.

With no bonus, the match comes out perfectly evenly, with each combatant getting 500 kills.

If I give Player a 1% bonus, then Player scores 522 kills versus the 478 kills of Mook.

With a 3% bonus, then the match comes out 553 to 447.

With a 5% bonus, then the match comes out 584 to 416.

Actually, let’s just put it on a chart:

I was expecting some kind of curve. Like, maybe early upgrades were useless but then scores would ramp up? Or maybe you’d get a lot of benefit from early bonuses, but their benefit would taper off? But no. We get a linear, shallow progression. At 0% bonus the two are evenly matched, and at a 10% bonus Player gets two-thirds of the kills.

It should be noted that an across-the-board ten percent bonus is pretty hard to achieve. I’ve put about 300 hours into Borderlands 2, and I have 10% bonus in just a couple of stats.

So that’s the experiment. This isn’t remotely definitive, but my guess is that a better test would still result in a similar outcome and a similar chart. My gut tells me that the slope might change slightly, but we wouldn’t see any sort of curve emerge.

But in case you want to have a go at it yourself, here’s the source. It’s only 200 lines of C++ code, and a quarter of that is the silly random number generator.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

#include <memory.h>
#include <stdio.h>
 
/*-----------------------------------------------------------------------------
The Mersenne Twister by Matsumoto and Nishimura. Our random number generator.
-----------------------------------------------------------------------------*/
 
#define LOWER_MASK            0x7fffffff 
#define M                     397
#define MATRIX_A              0x9908b0df 
#define N                     624
#define TEMPERING_MASK_B      0x9d2c5680
#define TEMPERING_MASK_C      0xefc60000
#define TEMPERING_SHIFT_L(y)  (y >> 18)
#define TEMPERING_SHIFT_S(y)  (y << 7)
#define TEMPERING_SHIFT_T(y)  (y << 15)
#define TEMPERING_SHIFT_U(y)  (y >> 11)
#define UPPER_MASK            0x80000000 
 
static int              k = 1;
static unsigned long    mag01[2] = {0x0, MATRIX_A};
static unsigned long    ptgfsr[N];
 
void RandomInit (unsigned long seed)
{
  mag01[0] = 0;
  mag01[1] = MATRIX_A;
  ptgfsr[0] = seed;
  for (k = 1; k < N; k++)
    ptgfsr[k] = 69069 * ptgfsr[k - 1];
  k = 1;
}
 
unsigned long RandomVal (void)
{
 
  int		            kk;
  unsigned long	    y; 
 
  if (k == N) {
    for (kk = 0; kk < N - M; kk++) {
      y = (ptgfsr[kk] & UPPER_MASK) | (ptgfsr[kk + 1] & LOWER_MASK);
      ptgfsr[kk] = ptgfsr[kk + M] ^ (y >> 1) ^ mag01[y & 0x1];
      }
    for (; kk < N - 1; kk++) {
      y = (ptgfsr[kk] & UPPER_MASK) | (ptgfsr[kk + 1] & LOWER_MASK);
      ptgfsr[kk] = ptgfsr[kk + (M - N)] ^ (y >> 1) ^ mag01[y & 0x1];
      }
    y = (ptgfsr[N - 1] & UPPER_MASK) | (ptgfsr[0] & LOWER_MASK);
    ptgfsr[N - 1] = ptgfsr[M - 1] ^ (y >> 1) ^ mag01[y & 0x1];
    k = 0;
  }
  y = ptgfsr[k++];
  y ^= TEMPERING_SHIFT_U (y);
  y ^= TEMPERING_SHIFT_S (y) & TEMPERING_MASK_B;
  y ^= TEMPERING_SHIFT_T (y) & TEMPERING_MASK_C;
  return y ^= TEMPERING_SHIFT_L (y);
}
 
/*-----------------------------------------------------------------------------
We can really change the outcome of the sim by altering these values.
-----------------------------------------------------------------------------*/
 
#define BASE_HITPOINTS    1000
#define BASE_HIT_CHANCE   25
#define BASE_CRIT_CHANCE  10
#define BASE_DAMAGE       15
#define CRITICAL_DAMAGE   1.0f
#define REFIRE_TIME       100
#define RELOAD_TIME       500
#define MAG_SIZE          20
 
/*-----------------------------------------------------------------------------
Our class for enacting the fight.
-----------------------------------------------------------------------------*/
 
class Fighter
{
private:
  float     _hitpoints;
  int       _cooldown;
  int       _bullets;
  int       _full_mag;
  int       _reload;
  float     _bonus;
  int       _next_shot;
  char      _bar[21];
 
public:
  float     Health () { return _hitpoints; }
  float     BonusPercent () { return _bonus * 0.01f; }
  void      Hit (float damage)  {    _hitpoints -= damage;   }
  bool      Dead () { return _hitpoints <= 0.0f; }
 
  //A status bar showing what this Fighter is doing. Fixed length for easy console viewing.
  char*     Bar () {
    if (_reload) 
      sprintf (_bar, "%3d [reloading] %c", (int)_hitpoints, _cooldown <= 0 ? 'x' : ' ');
    else 
      sprintf (_bar, "%3d [%3d / %3d] %c", (int)_hitpoints, _bullets, _full_mag, _cooldown <= 0 ? 'x' : ' ');
    return _bar;
  }
 
  void      Respawn ()
  {
    _hitpoints = BASE_HITPOINTS + (BASE_HITPOINTS * BonusPercent ());
    _bullets = _full_mag;
    _reload = 0;
    _next_shot = 0;
    _cooldown = 0;
  }
 
  void      Spawn (float bonus=0)
  {
    _bonus = bonus;
    _full_mag = MAG_SIZE + (int)(MAG_SIZE * BonusPercent ());
    Respawn ();
  }
 
  float   Shoot ()
  {
    int   roll;
    float damage;
 
    //Do we need to reload?
    if (!_reload && _bullets < 1) {
      _reload = RELOAD_TIME - (int)(RELOAD_TIME * BonusPercent ());
    }
    //Are we reloading?
    if (_reload) {
      _reload--;
      if (_reload == 0) {
        _bullets = _full_mag;
        _cooldown = 0;
      }
      return 0.0f;
    }
    //Are we ready to fire?
    if (_cooldown>0) {
      _cooldown--;
      return 0.0f;
    }
    //So we pulled the trigger. Put the weapon on cooldown.
    _cooldown = 100 - (int)(50.0f * BonusPercent ());
    _bullets--;
    //Roll to hit...
    roll = RandomVal () % 100 + BASE_HIT_CHANCE;
    roll += (int)_bonus;
    if (roll < 100) // We missed.
      return 0.0f;
    //Calculate damage.
    damage = BASE_DAMAGE;
    damage += (float)BASE_DAMAGE * BonusPercent ();
    //Roll for crit...
    roll = RandomVal () % 100 + BASE_CRIT_CHANCE;
    roll += (int)_bonus;
    if (roll > 100) //Yup, a crit.
      damage += damage * (CRITICAL_DAMAGE + BonusPercent ());
    return damage;    
  }
};
 
/*-----------------------------------------------------------------------------
And now the program itself.
-----------------------------------------------------------------------------*/
 
static bool over;
static int  turn;
static int  deaths_total;
static int  deaths_player;
static int  deaths_mook;
static int  msg_count;
 
int main (int argc, char* argv[])
{
  Fighter   player, mook;
 
  player.Spawn (5.0f);
  mook.Spawn ();
  RandomInit (2);
  while (!over) {
    //Have these two idiots shoot each other at exactly the same time, so we 
    //don't have to worry about who shot first. (It wasn't Greedo.)
    mook.Hit (player.Shoot ());
    player.Hit (mook.Shoot ());
    //Only print info occasionally, or the program takes forever.
    if ((msg_count % 500) == 0)
      printf ("%5d %3d Player: %s | %3d Mook: %s\n", turn, deaths_mook, player.Bar (), deaths_player, mook.Bar ());
    msg_count++;
    //See if either one died in the exchange.
    if (player.Dead ()) {
      player.Respawn ();
      deaths_player++;
      deaths_total++;
    }
    if (mook.Dead ()) {
      mook.Respawn ();
      deaths_mook++;
      deaths_total++;
    }
    if (deaths_total >= 1000) 
      over = true;
    turn++;
  }
  printf ("Player kills: %d\n", deaths_mook);
  printf ("Mook kills: %d\n", deaths_player);
  return 0;
}

Shamus Young is a programmer, an author, and nearly a composer. He works on this site full time. If you'd like to support him, you can do so via Patreon or PayPal.