diff --git a/src/actions.cc b/src/actions.cc
index e5c4d91..c21b36a 100644
--- a/src/actions.cc
+++ b/src/actions.cc
@@ -293,8 +293,8 @@ void _show_damage_to_object(Object* a1, int damage, int flags, Object* weapon, b
 
                     reg_anim_animate(a1, anim, 0);
 
-                    int randomDistance = randomBetween(2, 5);
-                    int randomRotation = randomBetween(0, 5);
+                    int randomDistance = Random::between(2, 5);
+                    int randomRotation = Random::between(0, 5);
 
                     while (randomDistance > 0) {
                         int tile = tileGetTileInDirection(a1->tile, randomRotation, randomDistance);
@@ -1714,7 +1714,7 @@ int _finished_explosion(Object* a1, Object* a2)
 // 0x4132CC
 int _compute_explosion_damage(int min, int max, Object* a3, int* a4)
 {
-    int v5 = randomBetween(min, max);
+    int v5 = Random::between(min, max);
     int v7 = v5 - critterGetStat(a3, STAT_DAMAGE_THRESHOLD_EXPLOSION);
     if (v7 > 0) {
         v7 -= critterGetStat(a3, STAT_DAMAGE_RESISTANCE_EXPLOSION) * v7 / 100;
@@ -1881,7 +1881,7 @@ int _compute_dmg_damage(int min, int max, Object* obj, int* a4, int damageType)
         a4 = NULL;
     }
 
-    int v8 = randomBetween(min, max);
+    int v8 = Random::between(min, max);
     int v10 = v8 - critterGetStat(obj, STAT_DAMAGE_THRESHOLD + damageType);
     if (v10 > 0) {
         v10 -= critterGetStat(obj, STAT_DAMAGE_RESISTANCE + damageType) * v10 / 100;
diff --git a/src/animation.cc b/src/animation.cc
index 3394495..cab1be5 100644
--- a/src/animation.cc
+++ b/src/animation.cc
@@ -2625,7 +2625,7 @@ void _dude_fidget()
 
     int v13;
     if (v5 != 0) {
-        int r = randomBetween(0, v5 - 1);
+        int r = Random::between(0, v5 - 1);
         Object* object = dword_56C7E0[r];
 
         reg_anim_begin(0x201);
@@ -2663,7 +2663,7 @@ void _dude_fidget()
         v13 = 7;
     }
 
-    _next_time = randomBetween(0, 3000) + 1000 * v13;
+    _next_time = Random::between(0, 3000) + 1000 * v13;
 }
 
 // 0x418378
diff --git a/src/combat.cc b/src/combat.cc
index 5f5eaa9..fd143ff 100644
--- a/src/combat.cc
+++ b/src/combat.cc
@@ -2701,11 +2701,11 @@ void _combat_give_exps(int exp_points)
         return;
     }
 
-    v9.num = randomBetween(0, 3) + 622; // generate prefix for message
+    v9.num = Random::between(0, 3) + 622; // generate prefix for message
 
     current_hp = critterGetStat(gDude, STAT_CURRENT_HIT_POINTS);
     max_hp = critterGetStat(gDude, STAT_MAXIMUM_HIT_POINTS);
-    if (current_hp == max_hp && randomBetween(0, 100) > 65) {
+    if (current_hp == max_hp && Random::between(0, 100) > 65) {
         v9.num = 626; // Best possible prefix: For destroying your enemies without taking a scratch,
     }
 
@@ -3288,7 +3288,7 @@ void attackInit(Attack* attack, Object* attacker, Object* defender, int hitMode,
 // 0x422F3C
 int _combat_attack(Object* a1, Object* a2, int hitMode, int hitLocation)
 {
-    if (a1 != gDude && hitMode == HIT_MODE_PUNCH && randomBetween(1, 4) == 1) {
+    if (a1 != gDude && hitMode == HIT_MODE_PUNCH && Random::between(1, 4) == 1) {
         int fid = buildFid(1, a1->fid & 0xFFF, ANIM_KICK_LEG, (a1->fid & 0xF000) >> 12, (a1->fid & 0x70000000) >> 28);
         if (artExists(fid)) {
             hitMode = HIT_MODE_KICK;
@@ -3373,7 +3373,7 @@ bool _check_ranged_miss(Attack* attack)
     int range = _item_w_range(attack->attacker, attack->hitMode);
     int to = _tile_num_beyond(attack->attacker->tile, attack->defender->tile, range);
 
-    int roll = ROLL_FAILURE;
+    int roll = Random::Roll::FAILURE;
     Object* critter = attack->attacker;
     if (critter != NULL) {
         int curr = attack->attacker->tile;
@@ -3382,7 +3382,7 @@ bool _check_ranged_miss(Attack* attack)
             if (critter != NULL) {
                 if ((critter->flags & OBJECT_FLAG_0x80000000) == 0) {
                     if ((critter->fid & 0xF000000) >> 24 != OBJ_TYPE_CRITTER) {
-                        roll = ROLL_SUCCESS;
+                        roll = Random::Roll::SUCCESS;
                         break;
                     }
 
@@ -3392,8 +3392,8 @@ bool _check_ranged_miss(Attack* attack)
                             v6 = 5;
                         }
 
-                        if (randomBetween(1, 100) <= v6) {
-                            roll = ROLL_SUCCESS;
+                        if (Random::between(1, 100) <= v6) {
+                            roll = Random::Roll::SUCCESS;
                             break;
                         }
                     }
@@ -3410,7 +3410,7 @@ bool _check_ranged_miss(Attack* attack)
 
     attack->defenderHitLocation = HIT_LOCATION_TORSO;
 
-    if (roll < ROLL_SUCCESS || critter == NULL || (critter->flags & OBJECT_FLAG_0x80000000) == 0) {
+    if (roll < Random::Roll::SUCCESS || critter == NULL || (critter->flags & OBJECT_FLAG_0x80000000) == 0) {
         return false;
     }
 
@@ -3448,7 +3448,7 @@ int _shoot_along_path(Attack* attack, int a2, int a3, int anim)
             }
 
             int a2a = 0;
-            while (randomBetween(1, 100) <= v8 && v5 > 0) {
+            while (Random::between(1, 100) <= v8 && v5 > 0) {
                 v5 -= 1;
                 a2a += 1;
             }
@@ -3510,13 +3510,13 @@ int _compute_spray(Attack* attack, int accuracy, int* a3, int* a4, int anim)
     *a4 = ammoQuantity;
 
     int criticalChance = critterGetStat(attack->attacker, STAT_CRITICAL_CHANCE);
-    int roll = randomRoll(accuracy, criticalChance, NULL);
+    int roll = Random::roll(accuracy, criticalChance, NULL);
 
-    if (roll == ROLL_CRITICAL_FAILURE) {
+    if (roll == Random::Roll::CRITICAL_FAILURE) {
         return roll;
     }
 
-    if (roll == ROLL_CRITICAL_SUCCESS) {
+    if (roll == Random::Roll::CRITICAL_SUCCESS) {
         accuracy += 20;
     }
 
@@ -3545,7 +3545,7 @@ int _compute_spray(Attack* attack, int accuracy, int* a3, int* a4, int anim)
     }
 
     for (int index = 0; index < v14; index += 1) {
-        if (randomRoll(accuracy, 0, NULL) >= ROLL_SUCCESS) {
+        if (Random::roll(accuracy, 0, NULL) >= Random::Roll::SUCCESS) {
             *a3 += 1;
         }
     }
@@ -3578,12 +3578,12 @@ int _compute_spray(Attack* attack, int accuracy, int* a3, int* a4, int anim)
     int v28 = _tile_num_beyond(attack->attacker->tile, v26, range);
     *a3 += _shoot_along_path(attack, v28, v30, anim);
 
-    if (roll != ROLL_FAILURE || *a3 <= 0 && attack->extrasLength <= 0) {
-        if (roll >= ROLL_SUCCESS && *a3 == 0 && attack->extrasLength == 0) {
-            roll = ROLL_FAILURE;
+    if (roll != Random::Roll::FAILURE || *a3 <= 0 && attack->extrasLength <= 0) {
+        if (roll >= Random::Roll::SUCCESS && *a3 == 0 && attack->extrasLength == 0) {
+            roll = Random::Roll::FAILURE;
         }
     } else {
-        roll = ROLL_SUCCESS;
+        roll = Random::Roll::SUCCESS;
     }
 
     return roll;
@@ -3594,7 +3594,7 @@ int attackComputeEnhancedKnockout(Attack* attack)
 {
     if (weaponGetPerk(attack->weapon) == PERK_WEAPON_ENHANCED_KNOCKOUT) {
         int difficulty = critterGetStat(attack->attacker, STAT_STRENGTH) - 8;
-        int chance = randomBetween(1, 100);
+        int chance = Random::between(1, 100);
         if (chance <= difficulty) {
             Object* weapon = NULL;
             if (attack->defender != gDude) {
@@ -3644,21 +3644,21 @@ int attackCompute(Attack* attack)
         roll = _compute_spray(attack, accuracy, &ammoQuantity, &v26, anim);
     } else {
         int chance = critterGetStat(attack->attacker, STAT_CRITICAL_CHANCE);
-        roll = randomRoll(accuracy, chance - _hit_location_penalty[attack->defenderHitLocation], NULL);
+        roll = Random::roll(accuracy, chance - _hit_location_penalty[attack->defenderHitLocation], NULL);
     }
 
-    if (roll == ROLL_FAILURE) {
+    if (roll == Random::Roll::FAILURE) {
         if (traitIsSelected(TRAIT_JINXED) || perkHasRank(gDude, PERK_JINXED)) {
-            if (randomBetween(0, 1) == 1) {
-                roll = ROLL_CRITICAL_FAILURE;
+            if (Random::between(0, 1) == 1) {
+                roll = Random::Roll::CRITICAL_FAILURE;
             }
         }
     }
 
-    if (roll == ROLL_SUCCESS) {
+    if (roll == Random::Roll::SUCCESS) {
         if ((attackType == ATTACK_TYPE_MELEE || attackType == ATTACK_TYPE_UNARMED) && attack->attacker == gDude) {
             if (perkHasRank(attack->attacker, PERK_SLAYER)) {
-                roll = ROLL_CRITICAL_SUCCESS;
+                roll = Random::Roll::CRITICAL_SUCCESS;
             }
 
             if (perkHasRank(gDude, PERK_SILENT_DEATH)
@@ -3668,13 +3668,13 @@ int attackCompute(Attack* attack)
                 damageMultiplier = 4;
             }
 
-            if (((attack->hitMode == HIT_MODE_HAMMER_PUNCH || attack->hitMode == HIT_MODE_POWER_KICK) && randomBetween(1, 100) <= 5)
-                || ((attack->hitMode == HIT_MODE_JAB || attack->hitMode == HIT_MODE_HOOK_KICK) && randomBetween(1, 100) <= 10)
-                || (attack->hitMode == HIT_MODE_HAYMAKER && randomBetween(1, 100) <= 15)
-                || (attack->hitMode == HIT_MODE_PALM_STRIKE && randomBetween(1, 100) <= 20)
-                || (attack->hitMode == HIT_MODE_PIERCING_STRIKE && randomBetween(1, 100) <= 40)
-                || (attack->hitMode == HIT_MODE_PIERCING_KICK && randomBetween(1, 100) <= 50)) {
-                roll = ROLL_CRITICAL_SUCCESS;
+            if (((attack->hitMode == HIT_MODE_HAMMER_PUNCH || attack->hitMode == HIT_MODE_POWER_KICK) && Random::between(1, 100) <= 5)
+                || ((attack->hitMode == HIT_MODE_JAB || attack->hitMode == HIT_MODE_HOOK_KICK) && Random::between(1, 100) <= 10)
+                || (attack->hitMode == HIT_MODE_HAYMAKER && Random::between(1, 100) <= 15)
+                || (attack->hitMode == HIT_MODE_PALM_STRIKE && Random::between(1, 100) <= 20)
+                || (attack->hitMode == HIT_MODE_PIERCING_STRIKE && Random::between(1, 100) <= 40)
+                || (attack->hitMode == HIT_MODE_PIERCING_KICK && Random::between(1, 100) <= 50)) {
+                roll = Random::Roll::CRITICAL_SUCCESS;
             }
         }
     }
@@ -3682,12 +3682,12 @@ int attackCompute(Attack* attack)
     if (attackType == ATTACK_TYPE_RANGED) {
         attack->ammoQuantity = v26;
 
-        if (roll == ROLL_SUCCESS && attack->attacker == gDude) {
+        if (roll == Random::Roll::SUCCESS && attack->attacker == gDude) {
             if (perkGetRank(gDude, PERK_SNIPER) != 0) {
-                int d10 = randomBetween(1, 10);
+                int d10 = Random::between(1, 10);
                 int luck = critterGetStat(gDude, STAT_LUCK);
                 if (d10 <= luck) {
-                    roll = ROLL_CRITICAL_SUCCESS;
+                    roll = Random::Roll::CRITICAL_SUCCESS;
                 }
             }
         }
@@ -3702,20 +3702,20 @@ int attackCompute(Attack* attack)
     }
 
     switch (roll) {
-    case ROLL_CRITICAL_SUCCESS:
+    case Random::Roll::CRITICAL_SUCCESS:
         damageMultiplier = attackComputeCriticalHit(attack);
         // FALLTHROUGH
-    case ROLL_SUCCESS:
+    case Random::Roll::SUCCESS:
         attack->attackerFlags |= DAM_HIT;
         attackComputeEnhancedKnockout(attack);
         attackComputeDamage(attack, ammoQuantity, damageMultiplier);
         break;
-    case ROLL_FAILURE:
+    case Random::Roll::FAILURE:
         if (attackType == ATTACK_TYPE_RANGED || attackType == ATTACK_TYPE_THROW) {
             _check_ranged_miss(attack);
         }
         break;
-    case ROLL_CRITICAL_FAILURE:
+    case Random::Roll::CRITICAL_FAILURE:
         attackComputeCriticalFailure(attack);
         break;
     }
@@ -3724,12 +3724,12 @@ int attackCompute(Attack* attack)
         if ((attack->attackerFlags & (DAM_HIT | DAM_CRITICAL)) == 0) {
             int tile;
             if (isGrenade) {
-                int throwDistance = randomBetween(1, distance / 2);
+                int throwDistance = Random::between(1, distance / 2);
                 if (throwDistance == 0) {
                     throwDistance = 1;
                 }
 
-                int rotation = randomBetween(0, 5);
+                int rotation = Random::between(0, 5);
                 tile = tileGetTileInDirection(attack->defender->tile, rotation, throwDistance);
             } else {
                 tile = _tile_num_beyond(attack->attacker->tile, attack->defender->tile, range);
@@ -3880,7 +3880,7 @@ int attackComputeCriticalHit(Attack* attack)
 
     attack->attackerFlags |= DAM_CRITICAL;
 
-    int chance = randomBetween(1, 100);
+    int chance = Random::between(1, 100);
 
     chance += critterGetStat(attack->attacker, STAT_BETTER_CRITICALS);
 
@@ -3913,7 +3913,7 @@ int attackComputeCriticalHit(Attack* attack)
     attack->criticalMessageId = criticalHitDescription->messageId;
 
     if (criticalHitDescription->massiveCriticalStat != -1) {
-        if (statRoll(defender, criticalHitDescription->massiveCriticalStat, criticalHitDescription->massiveCriticalStatModifier, NULL) <= ROLL_FAILURE) {
+        if (statRoll(defender, criticalHitDescription->massiveCriticalStat, criticalHitDescription->massiveCriticalStatModifier, NULL) <= Random::Roll::FAILURE) {
             attack->defenderFlags |= criticalHitDescription->massiveCriticalFlags;
             attack->criticalMessageId = criticalHitDescription->massiveCriticalMessageId;
         }
@@ -3922,7 +3922,7 @@ int attackComputeCriticalHit(Attack* attack)
     if ((attack->defenderFlags & DAM_CRIP_RANDOM) != 0) {
         attack->defenderFlags &= ~DAM_CRIP_RANDOM;
 
-        switch (randomBetween(0, 3)) {
+        switch (Random::between(0, 3)) {
         case 0:
             attack->defenderFlags |= DAM_CRIP_LEG_LEFT;
             break;
@@ -3991,7 +3991,7 @@ int attackComputeCriticalFailure(Attack* attack)
         criticalFailureTableIndex = 0;
     }
 
-    int chance = randomBetween(1, 100) - 5 * (critterGetStat(attack->attacker, STAT_LUCK) - 5);
+    int chance = Random::between(1, 100) - 5 * (critterGetStat(attack->attacker, STAT_LUCK) - 5);
 
     int effect;
     if (chance <= 20)
@@ -4038,7 +4038,7 @@ int attackComputeCriticalFailure(Attack* attack)
     if ((attack->attackerFlags & DAM_CRIP_RANDOM) != 0) {
         attack->attackerFlags &= ~DAM_CRIP_RANDOM;
 
-        switch (randomBetween(0, 3)) {
+        switch (Random::between(0, 3)) {
         case 0:
             attack->attackerFlags |= DAM_CRIP_LEG_LEFT;
             break;
@@ -4412,7 +4412,7 @@ void attackComputeDamage(Attack* attack, int ammoQuantity, int a3)
         bool hasStonewall = false;
         if (critter == gDude) {
             if (perkGetRank(critter, PERK_STONEWALL) != 0) {
-                int chance = randomBetween(0, 100);
+                int chance = Random::between(0, 100);
                 hasStonewall = true;
                 if (chance < 50) {
                     shouldKnockback = false;
diff --git a/src/combat_ai.cc b/src/combat_ai.cc
index 2c17431..1086888 100644
--- a/src/combat_ai.cc
+++ b/src/combat_ai.cc
@@ -911,7 +911,7 @@ int _ai_check_drugs(Object* critter)
             }
         }
 
-        if (!v28 && v26 > 0 && randomBetween(0, 100) < v26) {
+        if (!v28 && v26 > 0 && Random::between(0, 100) < v26) {
             while (critter->data.critter.combat.ap >= 2) {
                 Object* drug = _inven_find_type(critter, ITEM_TYPE_DRUG, &token);
                 if (drug == NULL) {
@@ -1587,7 +1587,7 @@ Object* _ai_best_weapon(Object* attacker, Object* weapon1, Object* weapon2, Obje
 
     AiPacket* ai = aiGetPacket(attacker);
     if (ai->best_weapon == BEST_WEAPON_RANDOM) {
-        return randomBetween(1, 100) <= 50 ? weapon1 : weapon2;
+        return Random::between(1, 100) <= 50 ? weapon1 : weapon2;
     }
     int minDamage;
     int maxDamage;
@@ -2024,7 +2024,7 @@ int _ai_pick_hit_mode(Object* a1, Object* a2, Object* a3)
             useSecondaryMode = true;
             break;
         case AREA_ATTACK_MODE_SOMETIMES:
-            if (randomBetween(1, ai->secondary_freq) == 1) {
+            if (Random::between(1, ai->secondary_freq) == 1) {
                 useSecondaryMode = true;
             }
             break;
@@ -2049,7 +2049,7 @@ int _ai_pick_hit_mode(Object* a1, Object* a2, Object* a3)
         }
     } else {
         if (intelligence < 6 || objectGetDistanceBetween(a1, a3) < 10) {
-            if (randomBetween(1, ai->secondary_freq) == 1) {
+            if (Random::between(1, ai->secondary_freq) == 1) {
                 useSecondaryMode = true;
             }
         }
@@ -2357,7 +2357,7 @@ int _ai_called_shot(Object* a1, Object* a2, int a3)
     if (_item_w_mp_cost(a1, a3, 1) <= a1->data.critter.combat.ap) {
         if (_item_w_called_shot(a1, a3)) {
             ai = aiGetPacket(a1);
-            if (randomBetween(1, ai->called_freq) == 1) {
+            if (Random::between(1, ai->called_freq) == 1) {
                 combat_difficulty = 1;
                 configGetInt(&gGameConfig, GAME_CONFIG_PREFERENCES_KEY, GAME_CONFIG_COMBAT_DIFFICULTY_KEY, &combat_difficulty);
                 if (combat_difficulty) {
@@ -2371,7 +2371,7 @@ int _ai_called_shot(Object* a1, Object* a2, int a3)
                 }
 
                 if (critterGetStat(a1, STAT_INTELLIGENCE) >= v6) {
-                    v5 = randomBetween(0, 8);
+                    v5 = Random::between(0, 8);
                     v7 = _determine_to_hit(a1, a2, a3, v5);
                     if (v7 < ai->min_to_hit) {
                         v5 = 3;
@@ -3012,7 +3012,7 @@ int _combatai_msg(Object* a1, Attack* attack, int type, int delay)
 
     debugPrint("%s is using %s packet with a %d%% chance to taunt\n", objectGetName(a1), ai->name, ai->chance);
 
-    if (randomBetween(1, 100) > ai->chance) {
+    if (Random::between(1, 100) > ai->chance) {
         return -1;
     }
 
@@ -3055,7 +3055,7 @@ int _combatai_msg(Object* a1, Attack* attack, int type, int delay)
     }
 
     MessageListItem messageListItem;
-    messageListItem.num = randomBetween(start, end);
+    messageListItem.num = Random::between(start, end);
     if (!messageListGetItem(&gCombatAiMessageList, &messageListItem)) {
         debugPrint("\nERROR: combatai_msg: Couldn't find message # %d for %s", messageListItem.num, critterGetName(a1));
         return -1;
@@ -3110,7 +3110,7 @@ Object* _combat_ai_random_target(Attack* attack)
 
     if (_curr_crit_num != 0) {
         // Randomize starting critter.
-        int start = randomBetween(0, _curr_crit_num - 1);
+        int start = Random::between(0, _curr_crit_num - 1);
         int index = start;
         while (true) {
             Object* obj = _curr_crit_list[index];
diff --git a/src/critter.cc b/src/critter.cc
index 968e5e2..fb58b14 100644
--- a/src/critter.cc
+++ b/src/critter.cc
@@ -466,7 +466,7 @@ int _critter_check_rads(Object* obj)
     else
         radiationLevel = RADIATION_LEVEL_NONE;
 
-    if (statRoll(obj, STAT_ENDURANCE, gRadiationEnduranceModifiers[radiationLevel], NULL) <= ROLL_FAILURE) {
+    if (statRoll(obj, STAT_ENDURANCE, gRadiationEnduranceModifiers[radiationLevel], NULL) <= Random::Roll::FAILURE) {
         radiationLevel++;
     }
 
@@ -479,7 +479,7 @@ int _critter_check_rads(Object* obj)
 
         radiationEvent->radiationLevel = radiationLevel;
         radiationEvent->isHealing = 0;
-        queueAddEvent(36000 * randomBetween(4, 18), obj, radiationEvent, EVENT_TYPE_RADIATION);
+        queueAddEvent(36000 * Random::between(4, 18), obj, radiationEvent, EVENT_TYPE_RADIATION);
     }
 
     proto->critter.data.flags &= ~(0x02);
@@ -1126,7 +1126,7 @@ int sneakEventProcess(Object* obj, void* data)
     int time;
 
     int sneak = skillGetValue(gDude, SKILL_SNEAK);
-    if (skillRoll(gDude, SKILL_SNEAK, 0, NULL) < ROLL_SUCCESS) {
+    if (skillRoll(gDude, SKILL_SNEAK, 0, NULL) < Random::Roll::SUCCESS) {
         time = 600;
         _sneak_working = false;
 
diff --git a/src/endgame.cc b/src/endgame.cc
index 8462148..99242f6 100644
--- a/src/endgame.cc
+++ b/src/endgame.cc
@@ -1067,7 +1067,7 @@ void endgameSetupDeathEnding(int reason)
     }
 
     if (!specialEndingSelected) {
-        int chance = randomBetween(0, percentage);
+        int chance = Random::between(0, percentage);
 
         int accum = 0;
         for (int index = 0; index < gEndgameDeathEndingsLength; index++) {
diff --git a/src/game.cc b/src/game.cc
index 80a4cd4..a541018 100644
--- a/src/game.cc
+++ b/src/game.cc
@@ -157,7 +157,7 @@ int gameInitWithOptions(const char* windowTitle, bool isMapper, int font, int a4
 
     tileDisable();
 
-    randomInit();
+    Random::init();
     badwordsInit();
     skillsInit();
     statsInit();
@@ -326,7 +326,7 @@ void gameReset()
 {
     tileDisable();
     paletteReset();
-    randomReset();
+    Random::reset();
     skillsReset();
     statsReset();
     perksReset();
@@ -390,7 +390,7 @@ void gameExit()
     statsExit();
     skillsExit();
     traitsExit();
-    randomExit();
+    Random::exit();
     badwordsExit();
     automapExit();
     paletteExit();
diff --git a/src/game_dialog.cc b/src/game_dialog.cc
index b1381e8..1cd9370 100644
--- a/src/game_dialog.cc
+++ b/src/game_dialog.cc
@@ -2287,7 +2287,7 @@ void _gdSetupFidget(int headFrmId, int reaction)
         return;
     }
 
-    int chance = randomBetween(1, 100) + _dialogue_seconds_since_last_input / 2;
+    int chance = Random::between(1, 100) + _dialogue_seconds_since_last_input / 2;
 
     int fidget = fidgetCount;
     switch (fidgetCount) {
@@ -2632,7 +2632,7 @@ void gameDialogTicker()
         if (getTicksSince(gGameDialogFidgetLastUpdateTimestamp) >= _tocksWaiting) {
             _can_start_new_fidget = false;
             _dialogue_seconds_since_last_input += _tocksWaiting / 1000;
-            _tocksWaiting = 1000 * (randomBetween(0, 3) + 4);
+            _tocksWaiting = 1000 * (Random::between(0, 3) + 4);
             _gdSetupFidget(gGameDialogFidgetFid & 0xFFF, (gGameDialogFidgetFid & 0xFF0000) >> 16);
         }
         return;
@@ -3415,11 +3415,11 @@ int _gdPickAIUpdateMsg(Object* critter)
 
     for (int index = 0; index < 3; index++) {
         if (critter->pid == pids[index]) {
-            return 677 + randomBetween(0, 1);
+            return 677 + Random::between(0, 1);
         }
     }
 
-    return 670 + randomBetween(0, 4);
+    return 670 + Random::between(0, 4);
 }
 
 // 0x449330
diff --git a/src/game_sound.cc b/src/game_sound.cc
index 132f396..3cb81fb 100644
--- a/src/game_sound.cc
+++ b/src/game_sound.cc
@@ -2076,7 +2076,7 @@ int ambientSoundEffectEventProcess(Object* a1, void* data)
         return 0;
     }
 
-    int delay = 10 * randomBetween(15, 20);
+    int delay = 10 * Random::between(15, 20);
     if (ambientSoundEffectGetLength() > 0) {
         nextSoundEffectEvent->ambientSoundEffectIndex = ambientSoundEffectGetRandom();
         if (queueAddEvent(delay, NULL, nextSoundEffectEvent, EVENT_TYPE_GSOUND_SFX_EVENT) == -1) {
diff --git a/src/interpreter_extra.cc b/src/interpreter_extra.cc
index 3be7860..d7c8088 100644
--- a/src/interpreter_extra.cc
+++ b/src/interpreter_extra.cc
@@ -469,7 +469,7 @@ void opRollVsSkill(Program* program)
     int skill = data[1];
     int modifier = data[0];
 
-    int roll = ROLL_CRITICAL_FAILURE;
+    int roll = Random::Roll::CRITICAL_FAILURE;
     if (object != NULL) {
         if ((object->pid >> 24) == OBJ_TYPE_CRITTER) {
             int sid = scriptGetSid(program);
@@ -583,12 +583,12 @@ void opSuccess(Program* program)
     int result = -1;
 
     switch (data) {
-    case ROLL_CRITICAL_FAILURE:
-    case ROLL_FAILURE:
+    case Random::Roll::CRITICAL_FAILURE:
+    case Random::Roll::FAILURE:
         result = 0;
         break;
-    case ROLL_SUCCESS:
-    case ROLL_CRITICAL_SUCCESS:
+    case Random::Roll::SUCCESS:
+    case Random::Roll::CRITICAL_SUCCESS:
         result = 1;
         break;
     }
@@ -615,12 +615,12 @@ void opCritical(Program* program)
     int result = -1;
 
     switch (data) {
-    case ROLL_CRITICAL_FAILURE:
-    case ROLL_CRITICAL_SUCCESS:
+    case Random::Roll::CRITICAL_FAILURE:
+    case Random::Roll::CRITICAL_SUCCESS:
         result = 1;
         break;
-    case ROLL_FAILURE:
-    case ROLL_SUCCESS:
+    case Random::Roll::FAILURE:
+    case Random::Roll::SUCCESS:
         result = 0;
         break;
     }
@@ -739,7 +739,7 @@ void opRandom(Program* program)
 
     int result;
     if (_vcr_status() == 2) {
-        result = randomBetween(data[1], data[0]);
+        result = Random::between(data[1], data[0]);
     } else {
         result = (data[0] - data[1]) / 2;
     }
diff --git a/src/inventory.cc b/src/inventory.cc
index d11347f..9b56213 100644
--- a/src/inventory.cc
+++ b/src/inventory.cc
@@ -1025,7 +1025,7 @@ void _exit_inventory(bool shouldEnableIso)
             Object* critter = v1.extras[index];
             if (critter != gDude
                 && critter->data.critter.combat.team != gDude->data.critter.combat.team
-                && statRoll(critter, STAT_PERCEPTION, 0, NULL) >= ROLL_SUCCESS) {
+                && statRoll(critter, STAT_PERCEPTION, 0, NULL) >= Random::Roll::SUCCESS) {
                 _critter_set_who_hit_me(critter, gDude);
 
                 if (v2 == NULL) {
diff --git a/src/item.cc b/src/item.cc
index 5545fcc..0f59efb 100644
--- a/src/item.cc
+++ b/src/item.cc
@@ -1224,7 +1224,7 @@ int weaponGetMeleeDamage(Object* critter, int hitMode)
         }
     }
 
-    return randomBetween(unarmedDamage + minDamage, unarmedDamage + meleeDamage + maxDamage);
+    return Random::between(unarmedDamage + minDamage, unarmedDamage + meleeDamage + maxDamage);
 }
 
 // 0x478570
@@ -2614,7 +2614,7 @@ void _perform_drug_effect(Object* critter, int* stats, int* mods, bool isImmedia
         }
 
         if (v32) {
-            v11 = randomBetween(mods[index - 1], mods[index]) + v10;
+            v11 = Random::between(mods[index - 1], mods[index]) + v10;
             v32 = false;
         } else {
             v11 = mods[index] + v10;
@@ -2777,7 +2777,7 @@ int _item_d_take_drug(Object* critter, Object* item)
             }
         }
 
-        if (randomBetween(1, 100) <= addictionChance) {
+        if (Random::between(1, 100) <= addictionChance) {
             _insert_withdrawal(critter, 1, proto->item.data.drug.withdrawalOnset, proto->item.data.drug.withdrawalEffect, item->pid);
 
             if (critter == gDude) {
diff --git a/src/loadsave.cc b/src/loadsave.cc
index baab366..e2361b4 100644
--- a/src/loadsave.cc
+++ b/src/loadsave.cc
@@ -100,7 +100,7 @@ SaveGameHandler* _master_save_list[LOAD_SAVE_HANDLER_COUNT] = {
     critterSave,
     killsSave,
     skillsSave,
-    randomSave,
+    Random::save,
     perksSave,
     combatSave,
     aiSave,
@@ -131,7 +131,7 @@ LoadGameHandler* _master_load_list[LOAD_SAVE_HANDLER_COUNT] = {
     critterLoad,
     killsLoad,
     skillsLoad,
-    randomLoad,
+    Random::load,
     perksLoad,
     combatLoad,
     aiLoad,
diff --git a/src/main.cc b/src/main.cc
index 6bbad81..ab3dda7 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -154,7 +154,7 @@ int falloutMain(int argc, char** argv)
                 mainMenuWindowFree();
                 if (characterSelectorOpen() == 2) {
                     gameMoviePlay(MOVIE_ELDER, GAME_MOVIE_STOP_MUSIC);
-                    randomSeedPrerandom(-1);
+                    Random::seedPrerandom(-1);
                     _main_load_new(_mainMap);
                     mainLoop(fpsLimiter);
                     paletteFadeTo(gPaletteWhite);
diff --git a/src/map.cc b/src/map.cc
index ba7c55d..2203955 100644
--- a/src/map.cc
+++ b/src/map.cc
@@ -1129,7 +1129,7 @@ int _map_age_dead_critters()
             Proto* proto;
             protoGetProto(obj->pid, &proto);
 
-            int frame = randomBetween(0, 3);
+            int frame = Random::between(0, 3);
             if ((proto->critter.flags & 0x800)) {
                 frame += 6;
             } else {
diff --git a/src/message.cc b/src/message.cc
index c0f6260..1341e30 100644
--- a/src/message.cc
+++ b/src/message.cc
@@ -518,7 +518,7 @@ bool messageListFilterBadwords(MessageList* messageList)
     }
 
     int replacementsCount = strlen(gBadwordsReplacements);
-    int replacementsIndex = randomBetween(1, replacementsCount) - 1;
+    int replacementsIndex = Random::between(1, replacementsCount) - 1;
 
     for (int index = 0; index < messageList->entries_num; index++) {
         MessageListItem* item = &(messageList->entries[index]);
diff --git a/src/party_member.cc b/src/party_member.cc
index 532b414..0c9a01c 100644
--- a/src/party_member.cc
+++ b/src/party_member.cc
@@ -1471,7 +1471,7 @@ int _partyMemberIncLevels()
 
         if (v24 != 0 || ptr_519DBC->field_8 == 0) {
             if (ptr_519DBC->field_8 == 0) {
-                if (v24 == 0 || randomBetween(0, 100) <= 100 * v24 / party_member->level_up_every) {
+                if (v24 == 0 || Random::between(0, 100) <= 100 * v24 / party_member->level_up_every) {
                     ptr_519DBC->field_0++;
                     if (v24 != 0) {
                         ptr_519DBC->field_8 = 1;
diff --git a/src/pipboy.cc b/src/pipboy.cc
index 1dbb0a1..6a238d6 100644
--- a/src/pipboy.cc
+++ b/src/pipboy.cc
@@ -2039,7 +2039,7 @@ int pipboyRenderScreensaver()
             break;
         }
 
-        double random = randomBetween(0, RAND_MAX);
+        double random = Random::between(0, RAND_MAX);
 
         // TODO: Figure out what this constant means. Probably somehow related
         // to RAND_MAX.
@@ -2054,7 +2054,7 @@ int pipboyRenderScreensaver()
             if (index < PIPBOY_BOMB_COUNT) {
                 PipboyBomb* bomb = &(bombs[index]);
                 int v27 = (350 - gPipboyFrmSizes[PIPBOY_FRM_BOMB].width / 4) + (406 - gPipboyFrmSizes[PIPBOY_FRM_BOMB].height / 4);
-                int v5 = (int)((double)randomBetween(0, RAND_MAX) / (double)RAND_MAX * (double)v27);
+                int v5 = (int)((double)Random::between(0, RAND_MAX) / (double)RAND_MAX * (double)v27);
                 int v6 = gPipboyFrmSizes[PIPBOY_FRM_BOMB].height / 4;
                 if (PIPBOY_WINDOW_CONTENT_VIEW_HEIGHT - v6 >= v5) {
                     bomb->x = 602;
@@ -2065,7 +2065,7 @@ int pipboyRenderScreensaver()
                 }
 
                 bomb->field_10 = 1;
-                bomb->field_8 = (float)((double)randomBetween(0, RAND_MAX) * (2.75 / RAND_MAX) + 0.15);
+                bomb->field_8 = (float)((double)Random::between(0, RAND_MAX) * (2.75 / RAND_MAX) + 0.15);
                 bomb->field_C = 0;
             }
         }
diff --git a/src/proto_instance.cc b/src/proto_instance.cc
index 28f0744..02296e4 100644
--- a/src/proto_instance.cc
+++ b/src/proto_instance.cc
@@ -180,7 +180,7 @@ int _obj_look_at_func(Object* a1, Object* a2, void (*a3)(char* string))
         MessageListItem messageListItem;
 
         if ((a2->pid >> 24) == OBJ_TYPE_CRITTER && critterIsDead(a2)) {
-            messageListItem.num = 491 + randomBetween(0, 1);
+            messageListItem.num = 491 + Random::between(0, 1);
         } else {
             messageListItem.num = 490;
         }
@@ -879,18 +879,18 @@ int _obj_use_explosive(Object* explosive)
 
             int roll;
             if (perkHasRank(gDude, PERK_DEMOLITION_EXPERT)) {
-                roll = ROLL_SUCCESS;
+                roll = Random::Roll::SUCCESS;
             } else {
                 roll = skillRoll(gDude, SKILL_TRAPS, 0, NULL);
             }
 
             int eventType;
             switch (roll) {
-            case ROLL_CRITICAL_FAILURE:
+            case Random::Roll::CRITICAL_FAILURE:
                 delay = 0;
                 eventType = EVENT_TYPE_EXPLOSION_FAILURE;
                 break;
-            case ROLL_FAILURE:
+            case Random::Roll::FAILURE:
                 eventType = EVENT_TYPE_EXPLOSION_FAILURE;
                 delay /= 2;
                 break;
@@ -1159,7 +1159,7 @@ int _protinst_default_use_item(Object* a1, Object* a2, Object* item)
             // 584: As you reach down, you realize that it is already dead.
             // 585: Alas, you are too late.
             // 586: That won't work on the dead.
-            messageListItem.num = 583 + randomBetween(0, 3);
+            messageListItem.num = 583 + Random::between(0, 3);
             if (messageListGetItem(&gProtoMessageList, &messageListItem)) {
                 displayMonitorAddMessage(messageListItem.text);
             }
@@ -1309,7 +1309,7 @@ int _protinst_use_item_on(Object* a1, Object* a2, Object* item)
         return 0;
     }
 
-    if (randomBetween(1, 10) != 1) {
+    if (Random::between(1, 10) != 1) {
         return 0;
     }
 
diff --git a/src/random.cc b/src/random.cc
index 6d059af..9c9510f 100644
--- a/src/random.cc
+++ b/src/random.cc
@@ -28,56 +28,56 @@ int _iv[32];
 int _idum;
 
 // 0x4A2FE0
-void randomInit()
+void Random::init()
 {
-    unsigned int randomSeed = randomGetSeed();
+    unsigned int randomSeed = getSeed();
     srand(randomSeed);
 
-    int pseudorandomSeed = randomInt32();
-    randomSeedPrerandomInternal(pseudorandomSeed);
+    int pseudorandomSeed = Int32();
+    seedPrerandomInternal(pseudorandomSeed);
 
-    randomValidatePrerandom();
+    validatePrerandom();
 }
 
 // Note: Collapsed.
 //
 // 0x4A2FFC
-int _roll_reset_()
+int Random::rollReset()
 {
     return 0;
 }
 
 // NOTE: Uncollapsed 0x4A2FFC.
-void randomReset()
+void Random::reset()
 {
-    _roll_reset_();
+    rollReset();
 }
 
 // NOTE: Uncollapsed 0x4A2FFC.
-void randomExit()
+void Random::exit()
 {
-    _roll_reset_();
+    rollReset();
 }
 
 // NOTE: Uncollapsed 0x4A2FFC.
-int randomSave(File* stream)
+int Random::save(File* stream)
 {
-    return _roll_reset_();
+    return rollReset();
 }
 
 // NOTE: Uncollapsed 0x4A2FFC.
-int randomLoad(File* stream)
+int Random::load(File* stream)
 {
-    return _roll_reset_();
+    return rollReset();
 }
 
 // Rolls d% against [difficulty].
 //
 // 0x4A3000
-int randomRoll(int difficulty, int criticalSuccessModifier, int* howMuchPtr)
+int Random::roll(int difficulty, int criticalSuccessModifier, int* howMuchPtr)
 {
-    int delta = difficulty - randomBetween(1, 100);
-    int result = randomTranslateRoll(delta, criticalSuccessModifier);
+    int delta = difficulty - Random::between(1, 100);
+    int result = translateRoll(delta, criticalSuccessModifier);
 
     if (howMuchPtr != NULL) {
         *howMuchPtr = delta;
@@ -90,27 +90,27 @@ int randomRoll(int difficulty, int criticalSuccessModifier, int* howMuchPtr)
 // criticals (starting from day 2).
 //
 // 0x4A3030
-int randomTranslateRoll(int delta, int criticalSuccessModifier)
+int Random::translateRoll(int delta, int criticalSuccessModifier)
 {
     int gameTime = gameTimeGetTime();
 
     int roll;
     if (delta < 0) {
-        roll = ROLL_FAILURE;
+        roll = Random::Roll::FAILURE;
 
         if ((gameTime / GAME_TIME_TICKS_PER_DAY) >= 1) {
             // 10% to become critical failure.
-            if (randomBetween(1, 100) <= -delta / 10) {
-                roll = ROLL_CRITICAL_FAILURE;
+            if (Random::between(1, 100) <= -delta / 10) {
+                roll = Random::Roll::CRITICAL_FAILURE;
             }
         }
     } else {
-        roll = ROLL_SUCCESS;
+        roll = Random::Roll::SUCCESS;
 
         if ((gameTime / GAME_TIME_TICKS_PER_DAY) >= 1) {
             // 10% + modifier to become critical success.
-            if (randomBetween(1, 100) <= delta / 10 + criticalSuccessModifier) {
-                roll = ROLL_CRITICAL_SUCCESS;
+            if (Random::between(1, 100) <= delta / 10 + criticalSuccessModifier) {
+                roll = Random::Roll::CRITICAL_SUCCESS;
             }
         }
     }
@@ -119,7 +119,7 @@ int randomTranslateRoll(int delta, int criticalSuccessModifier)
 }
 
 // 0x4A30C0
-int randomBetween(int min, int max)
+int Random::between(int min, int max)
 {
     int result;
 
@@ -138,7 +138,7 @@ int randomBetween(int min, int max)
 }
 
 // 0x4A30FC
-int getRandom(int max)
+int Random::getRandom(int max)
 {
     int v1 = 16807 * (_idum % 127773) - 2836 * (_idum / 127773);
 
@@ -160,18 +160,18 @@ int getRandom(int max)
 }
 
 // 0x4A31A0
-void randomSeedPrerandom(int seed)
+void Random::seedPrerandom(int seed)
 {
     if (seed == -1) {
         // NOTE: Uninline.
-        seed = randomInt32();
+        seed = Int32();
     }
 
-    randomSeedPrerandomInternal(seed);
+    seedPrerandomInternal(seed);
 }
 
 // 0x4A31C4
-int randomInt32()
+int Random::Int32()
 {
     int high = rand() << 16;
     int low = rand();
@@ -180,7 +180,7 @@ int randomInt32()
 }
 
 // 0x4A31E0
-void randomSeedPrerandomInternal(int seed)
+void Random::seedPrerandomInternal(int seed)
 {
     int num = seed;
     if (num < 1) {
@@ -206,13 +206,13 @@ void randomSeedPrerandomInternal(int seed)
 // Provides seed for random number generator.
 //
 // 0x4A3258
-unsigned int randomGetSeed()
+unsigned int Random::getSeed()
 {
     return timeGetTime();
 }
 
 // 0x4A3264
-void randomValidatePrerandom()
+void Random::validatePrerandom()
 {
     int results[25];
 
@@ -221,7 +221,7 @@ void randomValidatePrerandom()
     }
 
     for (int attempt = 0; attempt < 100000; attempt++) {
-        int value = randomBetween(1, 25);
+        int value = Random::between(1, 25);
         if (value - 1 < 0) {
             debugPrint("I made a negative number %d\n", value - 1);
         }
diff --git a/src/random.h b/src/random.h
index a514ac1..b438af5 100644
--- a/src/random.h
+++ b/src/random.h
@@ -3,35 +3,31 @@
 
 #include "db.h"
 
-typedef enum Roll {
-    ROLL_CRITICAL_FAILURE,
-    ROLL_FAILURE,
-    ROLL_SUCCESS,
-    ROLL_CRITICAL_SUCCESS,
-} Roll;
+class Random {
+public:
+    enum Roll {
+        CRITICAL_FAILURE,
+        FAILURE,
+        SUCCESS,
+        CRITICAL_SUCCESS,
+    };
+    static void init();
+    static void reset();
+    static void exit();
+    static int save(File* stream);
+    static int load(File* stream);
+    static int roll(int difficulty, int criticalSuccessModifier, int* howMuchPtr);
+    static int between(int min, int max);
+    static void seedPrerandom(int seed);
 
-extern const double dbl_50D4BA;
-extern const double dbl_50D4C2;
-
-extern int _iy;
-
-extern int _iv[32];
-extern int _idum;
-
-void randomInit();
-int _roll_reset_();
-void randomReset();
-void randomExit();
-int randomSave(File* stream);
-int randomLoad(File* stream);
-int randomRoll(int difficulty, int criticalSuccessModifier, int* howMuchPtr);
-int randomTranslateRoll(int delta, int criticalSuccessModifier);
-int randomBetween(int min, int max);
-int getRandom(int max);
-void randomSeedPrerandom(int seed);
-int randomInt32();
-void randomSeedPrerandomInternal(int seed);
-unsigned int randomGetSeed();
-void randomValidatePrerandom();
+private:
+    static int rollReset();
+    static int translateRoll(int delta, int criticalSuccessModifier);
+    static int getRandom(int max);
+    static int Int32();
+    static void seedPrerandomInternal(int seed);
+    static unsigned int getSeed();
+    static void validatePrerandom();
+};
 
 #endif /* RANDOM_H */
diff --git a/src/skill.cc b/src/skill.cc
index 2b21bf9..a96cfe0 100644
--- a/src/skill.cc
+++ b/src/skill.cc
@@ -418,7 +418,7 @@ int skillSubForce(Object* obj, int skill)
 int skillRoll(Object* critter, int skill, int modifier, int* howMuch)
 {
     if (!skillIsValid(skill)) {
-        return ROLL_FAILURE;
+        return Random::Roll::FAILURE;
     }
 
     if (critter == gDude && skill != SKILL_STEAL) {
@@ -441,7 +441,7 @@ int skillRoll(Object* critter, int skill, int modifier, int* howMuch)
     }
 
     int criticalChance = critterGetStat(critter, STAT_CRITICAL_CHANCE);
-    return randomRoll(skillValue + modifier, criticalChance, howMuch);
+    return Random::roll(skillValue + modifier, criticalChance, howMuch);
 }
 
 // 0x4AAB9C
@@ -542,7 +542,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
             // 590: You've taxed your ability with that skill. Wait a while.
             // 591: You're too tired.
             // 592: The strain might kill you.
-            messageListItem.num = 590 + randomBetween(0, 2);
+            messageListItem.num = 590 + Random::between(0, 2);
             if (messageListGetItem(&gSkillsMessageList, &messageListItem)) {
                 displayMonitorAddMessage(messageListItem.text);
             }
@@ -554,7 +554,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
             // 512: You can't heal the dead.
             // 513: Let the dead rest in peace.
             // 514: It's dead, get over it.
-            messageListItem.num = 512 + randomBetween(0, 2);
+            messageListItem.num = 512 + Random::between(0, 2);
             if (messageListGetItem(&gSkillsMessageList, &messageListItem)) {
                 debugPrint(messageListItem.text);
             }
@@ -567,13 +567,13 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
 
             int roll;
             if (critterGetBodyType(a2) == BODY_TYPE_ROBOTIC) {
-                roll = ROLL_FAILURE;
+                roll = Random::Roll::FAILURE;
             } else {
                 roll = skillRoll(obj, skill, criticalChance, &hpToHeal);
             }
 
-            if (roll == ROLL_SUCCESS || roll == ROLL_CRITICAL_SUCCESS) {
-                hpToHeal = randomBetween(minimumHpToHeal + 1, maximumHpToHeal + 5);
+            if (roll == Random::Roll::SUCCESS || roll == Random::Roll::CRITICAL_SUCCESS) {
+                hpToHeal = Random::between(minimumHpToHeal + 1, maximumHpToHeal + 5);
                 critterAdjustHitPoints(a2, hpToHeal);
 
                 if (obj == gDude) {
@@ -643,7 +643,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
             // 590: You've taxed your ability with that skill. Wait a while.
             // 591: You're too tired.
             // 592: The strain might kill you.
-            messageListItem.num = 590 + randomBetween(0, 2);
+            messageListItem.num = 590 + Random::between(0, 2);
             if (messageListGetItem(&gSkillsMessageList, &messageListItem)) {
                 displayMonitorAddMessage(messageListItem.text);
             }
@@ -655,7 +655,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
             // 512: You can't heal the dead.
             // 513: Let the dead rest in peace.
             // 514: It's dead, get over it.
-            messageListItem.num = 512 + randomBetween(0, 2);
+            messageListItem.num = 512 + Random::between(0, 2);
             if (messageListGetItem(&gSkillsMessageList, &messageListItem)) {
                 displayMonitorAddMessage(messageListItem.text);
             }
@@ -688,7 +688,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
 
                         MessageListItem prefix;
 
-                        if (roll == ROLL_SUCCESS || roll == ROLL_CRITICAL_SUCCESS) {
+                        if (roll == Random::Roll::SUCCESS || roll == Random::Roll::CRITICAL_SUCCESS) {
                             a2->data.critter.combat.results &= ~flags[index];
                             a2->data.critter.combat.maneuver &= ~CRITTER_MANUEVER_FLEEING;
 
@@ -721,14 +721,14 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
 
             int roll;
             if (critterGetBodyType(a2) == BODY_TYPE_ROBOTIC) {
-                roll = ROLL_FAILURE;
+                roll = Random::Roll::FAILURE;
             } else {
                 int skillValue = skillGetValue(obj, skill);
-                roll = randomRoll(skillValue, criticalChance, &hpToHeal);
+                roll = Random::roll(skillValue, criticalChance, &hpToHeal);
             }
 
-            if (roll == ROLL_SUCCESS || roll == ROLL_CRITICAL_SUCCESS) {
-                hpToHeal = randomBetween(minimumHpToHeal + 4, maximumHpToHeal + 10);
+            if (roll == Random::Roll::SUCCESS || roll == Random::Roll::CRITICAL_SUCCESS) {
+                hpToHeal = Random::between(minimumHpToHeal + 4, maximumHpToHeal + 10);
                 critterAdjustHitPoints(a2, hpToHeal);
 
                 if (obj == gDude) {
@@ -834,7 +834,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
             // 590: You've taxed your ability with that skill. Wait a while.
             // 591: You're too tired.
             // 592: The strain might kill you.
-            messageListItem.num = 590 + randomBetween(0, 2);
+            messageListItem.num = 590 + Random::between(0, 2);
             if (messageListGetItem(&gSkillsMessageList, &messageListItem)) {
                 displayMonitorAddMessage(messageListItem.text);
             }
@@ -875,7 +875,7 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
 
                     MessageListItem prefix;
 
-                    if (roll == ROLL_SUCCESS || roll == ROLL_CRITICAL_SUCCESS) {
+                    if (roll == Random::Roll::SUCCESS || roll == Random::Roll::CRITICAL_SUCCESS) {
                         a2->data.critter.combat.results &= ~flags[index];
                         a2->data.critter.combat.maneuver &= ~CRITTER_MANUEVER_FLEEING;
 
@@ -905,10 +905,10 @@ int skillUse(Object* obj, Object* a2, int skill, int criticalChanceModifier)
             }
 
             int skillValue = skillGetValue(obj, skill);
-            int roll = randomRoll(skillValue, criticalChance, &hpToHeal);
+            int roll = Random::roll(skillValue, criticalChance, &hpToHeal);
 
-            if (roll == ROLL_SUCCESS || roll == ROLL_CRITICAL_SUCCESS) {
-                hpToHeal = randomBetween(minimumHpToHeal + 4, maximumHpToHeal + 10);
+            if (roll == Random::Roll::SUCCESS || roll == Random::Roll::CRITICAL_SUCCESS) {
+                hpToHeal = Random::between(minimumHpToHeal + 4, maximumHpToHeal + 10);
                 critterAdjustHitPoints(a2, hpToHeal);
 
                 if (obj == gDude) {
@@ -1027,17 +1027,17 @@ int skillsPerformStealing(Object* a1, Object* a2, Object* item, bool isPlanting)
 
     int stealRoll;
     if (a1 == gDude && objectIsPartyMember(a2)) {
-        stealRoll = ROLL_CRITICAL_SUCCESS;
+        stealRoll = Random::Roll::CRITICAL_SUCCESS;
     } else {
         int criticalChance = critterGetStat(a1, STAT_CRITICAL_CHANCE);
-        stealRoll = randomRoll(stealChance, criticalChance, &howMuch);
+        stealRoll = Random::roll(stealChance, criticalChance, &howMuch);
     }
 
     int catchRoll;
-    if (stealRoll == ROLL_CRITICAL_SUCCESS) {
-        catchRoll = ROLL_CRITICAL_FAILURE;
-    } else if (stealRoll == ROLL_CRITICAL_FAILURE) {
-        catchRoll = ROLL_SUCCESS;
+    if (stealRoll == Random::Roll::CRITICAL_SUCCESS) {
+        catchRoll = Random::Roll::CRITICAL_FAILURE;
+    } else if (stealRoll == Random::Roll::CRITICAL_FAILURE) {
+        catchRoll = Random::Roll::SUCCESS;
     } else {
         int catchChance;
         if ((a2->pid >> 24) == OBJ_TYPE_CRITTER) {
@@ -1046,13 +1046,13 @@ int skillsPerformStealing(Object* a1, Object* a2, Object* item, bool isPlanting)
             catchChance = 30 - stealModifier;
         }
 
-        catchRoll = randomRoll(catchChance, 0, &howMuch);
+        catchRoll = Random::roll(catchChance, 0, &howMuch);
     }
 
     MessageListItem messageListItem;
     char text[60];
 
-    if (catchRoll != ROLL_SUCCESS && catchRoll != ROLL_CRITICAL_SUCCESS) {
+    if (catchRoll != Random::Roll::SUCCESS && catchRoll != Random::Roll::CRITICAL_SUCCESS) {
         // 571: You steal the %s.
         // 573: You plant the %s.
         messageListItem.num = isPlanting ? 573 : 571;
@@ -1174,7 +1174,7 @@ char* skillsGetGenericResponse(Object* critter, bool isDude)
         count = 5;
     }
 
-    int messageId = randomBetween(0, count);
+    int messageId = Random::between(0, count);
 
     MessageListItem messageListItem;
     char* msg = getmsg(&gSkillsMessageList, &messageListItem, baseMessageId + messageId);
diff --git a/src/stat.cc b/src/stat.cc
index 87f434f..5789195 100644
--- a/src/stat.cc
+++ b/src/stat.cc
@@ -686,17 +686,17 @@ int statGetFrmId(int stat)
 int statRoll(Object* critter, int stat, int modifier, int* howMuch)
 {
     int value = critterGetStat(critter, stat) + modifier;
-    int chance = randomBetween(PRIMARY_STAT_MIN, PRIMARY_STAT_MAX);
+    int chance = Random::between(PRIMARY_STAT_MIN, PRIMARY_STAT_MAX);
 
     if (howMuch != NULL) {
         *howMuch = value - chance;
     }
 
     if (chance <= value) {
-        return ROLL_SUCCESS;
+        return Random::Roll::SUCCESS;
     }
 
-    return ROLL_FAILURE;
+    return Random::Roll::FAILURE;
 }
 
 // 0x4AFAA8
diff --git a/src/world_map.cc b/src/world_map.cc
index 1d2cf5d..a044781 100644
--- a/src/world_map.cc
+++ b/src/world_map.cc
@@ -3203,7 +3203,7 @@ int _wmRndEncounterOccurred()
         }
     }
 
-    int chance = randomBetween(0, 100);
+    int chance = Random::between(0, 100);
     if (chance >= frequency) {
         return 0;
     }
@@ -3277,7 +3277,7 @@ int _wmRndEncounterOccurred()
 
         outdoorsman += tile->encounterDifficultyModifier;
 
-        if (randomBetween(1, 100) < outdoorsman) {
+        if (Random::between(1, 100) < outdoorsman) {
             randomEncounterIsDetected = true;
 
             int xp = 100 - outdoorsman;
@@ -3392,7 +3392,7 @@ int _wmRndEncounterPick()
     }
 
     int v1 = critterGetStat(gDude, STAT_LUCK) - 5;
-    int v2 = randomBetween(0, totalChance) + v1;
+    int v2 = Random::between(0, totalChance) + v1;
 
     if (perkHasRank(gDude, PERK_EXPLORER)) {
         v2 += 2;
@@ -3448,10 +3448,10 @@ int _wmRndEncounterPick()
     if (encounterTableEntry->map == -1) {
         if (encounterTable->mapsLength <= 0) {
             Terrain* terrain = &(gTerrains[_world_subtile->terrain]);
-            int randomMapIndex = randomBetween(0, terrain->mapsLength - 1);
+            int randomMapIndex = Random::between(0, terrain->mapsLength - 1);
             _EncounterMapID = terrain->maps[randomMapIndex];
         } else {
-            int randomMapIndex = randomBetween(0, encounterTable->mapsLength - 1);
+            int randomMapIndex = Random::between(0, encounterTable->mapsLength - 1);
             _EncounterMapID = encounterTable->maps[randomMapIndex];
         }
     } else {
@@ -3500,7 +3500,7 @@ int worldmapSetupRandomEncounter()
     for (int i = 0; i < encounterTableEntry->field_50; i++) {
         ENCOUNTER_ENTRY_ENC* v3 = &(encounterTableEntry->field_54[i]);
 
-        int v9 = randomBetween(v3->minQuantity, v3->maxQuantity);
+        int v9 = Random::between(v3->minQuantity, v3->maxQuantity);
 
         switch (gameDifficulty) {
         case GAME_DIFFICULTY_EASY:
@@ -3674,7 +3674,7 @@ int worldmapSetupCritters(int type_idx, Object** critterPtr, int critterCount)
                 if (v10->maximumQuantity == v10->minimumQuantity) {
                     quantity = v10->maximumQuantity;
                 } else {
-                    quantity = randomBetween(v10->minimumQuantity, v10->maximumQuantity);
+                    quantity = Random::between(v10->minimumQuantity, v10->maximumQuantity);
                 }
 
                 if (quantity == 0) {
@@ -3730,7 +3730,7 @@ int _wmSetupRndNextTileNumInit(ENC_BASE_TYPE* a1)
     switch (a1->position) {
     case ENCOUNTER_FORMATION_TYPE_SURROUNDING:
         _wmRndCenterTiles[0] = gDude->tile;
-        _wmRndTileDirs[0] = randomBetween(0, ROTATION_COUNT - 1);
+        _wmRndTileDirs[0] = Random::between(0, ROTATION_COUNT - 1);
 
         _wmRndOriginalCenterTile = _wmRndCenterTiles[0];
 
@@ -3743,7 +3743,7 @@ int _wmSetupRndNextTileNumInit(ENC_BASE_TYPE* a1)
         if (1) {
             MapInfo* map = &(gMaps[gMapHeader.field_34]);
             if (map->startPointsLength != 0) {
-                int rspIndex = randomBetween(0, map->startPointsLength - 1);
+                int rspIndex = Random::between(0, map->startPointsLength - 1);
                 MapStartPointInfo* rsp = &(map->startPoints[rspIndex]);
 
                 _wmRndCenterTiles[0] = rsp->tile;
@@ -3788,7 +3788,7 @@ int _wmSetupRndNextTileNum(ENC_BASE_TYPE* a1, ENC_BASE_TYPE_38* a2, int* out_til
                 if (a2->distance != 0) {
                     distance = a2->distance;
                 } else {
-                    distance = randomBetween(-2, 2);
+                    distance = Random::between(-2, 2);
 
                     distance += critterGetStat(gDude, STAT_PERCEPTION);
 
@@ -3810,8 +3810,8 @@ int _wmSetupRndNextTileNum(ENC_BASE_TYPE* a1, ENC_BASE_TYPE_38* a2, int* out_til
                     _wmRndTileDirs[0] = 0;
                 }
 
-                int randomizedDistance = randomBetween(0, distance / 2);
-                int randomizedRotation = randomBetween(0, ROTATION_COUNT - 1);
+                int randomizedDistance = Random::between(0, distance / 2);
+                int randomizedRotation = Random::between(0, ROTATION_COUNT - 1);
                 tile_num = tileGetTileInDirection(origin, (randomizedRotation + _wmRndTileDirs[0]) % ROTATION_COUNT, randomizedDistance);
             }
             break;
@@ -3927,7 +3927,7 @@ bool _wmEvalConditional(EncounterCondition* a1, int* a2)
             }
             break;
         case ENCOUNTER_CONDITION_TYPE_RANDOM:
-            value = randomBetween(0, 100);
+            value = Random::between(0, 100);
             if (value > ptr->param) {
                 matches = false;
             }
@@ -6011,7 +6011,7 @@ int ambientSoundEffectGetRandom()
         totalChances += sfx->chance;
     }
 
-    int chance = randomBetween(0, totalChances);
+    int chance = Random::between(0, totalChances);
     for (int index = 0; index < map->ambientSoundEffectsLength; index++) {
         MapAmbientSoundEffectInfo* sfx = &(map->ambientSoundEffects[index]);
         if (chance >= sfx->chance) {