Le bug de World of Warcraft qui a prédit une vraie pandémie : simulation épidémique en Python

En septembre 2005, Blizzard a introduit un nouveau boss dans World of Warcraft. Ce boss lançait un sort appelé « Corrupted Blood » : un effet de dégâts qui se transmettait entre joueurs proches.

Prévu pour rester dans la salle du boss.

En quelques heures, il avait infecté les villes principales du jeu. Des milliers de personnages mouraient. Des joueurs bas niveau étaient décimés en quelques secondes. Les zones peuplées ressemblaient à des scènes d’apocalypse.

Ce qui était censé être un mécanisme de combat localisé était devenu une épidémie virale simulée par accident.

Quand des chercheurs en épidémiologie ont appris l’incident, ils ont analysé les logs de Blizzard. Ils y ont trouvé des comportements humains face à une épidémie que leurs modèles théoriques prédisaient mais qu’ils n’avaient jamais pu observer en conditions réelles : la fuite, l’altruisme, la panique, les soignants qui s’approchent de la zone d’infection.

Voici ce que ce bug a appris à la science, et comment reproduire le modèle de propagation en Python.

---

Ce qui s’est passé dans WoW en septembre 2005

Hakkar le Soul Flayer était un boss du raid Zul’Gurub. Son sort Corrupted Blood infligeait des dégâts toutes les deux secondes et se transmettait aux joueurs proches dans un rayon défini. Conçu pour compliquer le combat de boss en exigeant une gestion de la distance entre joueurs.

La mécanique aurait dû rester confinée à la salle du boss. Deux vecteurs de transmission imprévus ont tout changé.

Premier vecteur : les familiers. Les joueurs de classe Hunter pouvaient invoquer des animaux familiers qui les accompagnaient. Ces familiers pouvaient être infectés par Corrupted Blood à l’intérieur du raid, mis en veille par leur propriétaire, transportés dans n’importe quelle zone du jeu, puis réinvoqués en milieu peuplé. L’animal réinvoqué transmettait alors le sort à tous les joueurs proches.

Deuxième vecteur : les téléportations. Des joueurs infectés utilisaient des sorts de téléportation pour quitter la salle du boss rapidement, emportant l’infection vers les zones peuplées avant d’en mourir.

En quelques heures, Ironforge et Orgrimmar, les deux villes principales du jeu, étaient des zones de contamination actives. Les personnages bas niveau, sans la résistance des personnages de haut niveau, mouraient instantanément au contact. Des joueurs qui n’avaient aucun lien avec le raid se retrouvaient tués par un effet dont ils ne comprenaient pas la source.

Blizzard a mis plusieurs jours à corriger le bug. La solution finale a été un hard reset de toutes les zones de jeu.

---

Pourquoi les épidémiologistes s’y sont intéressés

Deux publications de 2007 ont fait entrer l’incident dans la littérature scientifique. Ran Balicer, épidémiologiste à l’université Ben Gourion, a signé dans la revue Epidemiology un texte intitulé Modeling infectious diseases dissemination through online role-playing games, qui propose de traiter les mondes virtuels comme des terrains d’expérimentation pour tester des interventions de santé publique. La même année, Eric Lofgren et Nina Fefferman ont publié dans The Lancet Infectious Diseases un article qui situe l’épisode au 13 septembre 2005, sur un jeu qui comptait alors environ 4 millions de joueurs.

La thèse commune : Corrupted Blood était une simulation accidentelle de pandémie avec des sujets humains réels, qui réagissaient avec leurs propres comportements plutôt qu’avec ceux qu’un modèle leur prête.

Ce que les modèles épidémiologiques classiques peinent à capturer, c’est le comportement humain sous incertitude. Les équations différentielles du modèle SIR supposent des populations homogènes avec des comportements uniformes. La réalité est différente.

Dans WoW, les chercheurs ont observé :

• Des joueurs qui fuyaient les zones infectées, accélérant la propagation vers de nouvelles zones.
• Des joueurs qui se rapprochaient délibérément de la zone d’infection par curiosité ou pour aider, accélérant leur propre contamination.
• Des personnages soigneurs qui continuaient d’essayer de guérir les infectés malgré le risque, reproduisant le comportement des professionnels de santé en épidémie réelle.
• Des joueurs qui ignoraient les avertissements dans le chat et entraient dans les zones contaminées, reproduisant le comportement de non-conformité aux mesures sanitaires.

Quinze ans plus tard, pendant le Covid-19, plusieurs chercheurs ont cité l’incident Corrupted Blood comme précurseur utile pour modéliser les comportements humains en pandémie.

---

Le modèle SIR, et Corrupted Blood dedans

Le modèle SIR divise une population en trois compartiments : les Susceptibles, pas encore infectés, les Infectés, actuellement contagieux, et les Rétablis, immunisés ou décédés. Deux paramètres gouvernent la dynamique : le taux de transmission bêta, soit la probabilité qu’un susceptible devienne infecté au contact d’un infecté, et le taux de guérison gamma, soit la probabilité qu’un infecté se rétablisse par unité de temps.

Les trois compartiments et les deux paramètres

Tout le modèle tient dans une idée : à chaque instant, le nombre de nouvelles infections est proportionnel au produit du nombre de susceptibles par le nombre d’infectés. Plus il y a de porteurs et plus il reste de gens à contaminer, plus ça va vite. Quand l’un des deux s’épuise, l’épidémie s’arrête, et c’est presque toujours le stock de susceptibles qui s’épuise en premier.

import numpy as np
from scipy.integrate import odeint

def modele_sir(y: list, t: float, beta: float, gamma: float) -> list:
    """
    Equations différentielles du modèle SIR.
    
    y : [S, I, R] populations actuelles
    t : temps
    beta : taux de transmission
    gamma : taux de guérison
    """
    S, I, R = y
    N = S + I + R
    
    dS_dt = -beta * S * I / N
    dI_dt = beta * S * I / N - gamma * I
    dR_dt = gamma * I
    
    return [dS_dt, dI_dt, dR_dt]

def simuler_epidemie(
    population: int,
    infectes_initiaux: int,
    beta: float,
    gamma: float,
    jours: int
) -> dict:
    """Simule une épidémie sur une population donnée."""
    S0 = population - infectes_initiaux
    I0 = infectes_initiaux
    R0_initial = 0
    
    y0 = [S0, I0, R0_initial]
    t = np.linspace(0, jours, jours * 10)
    
    solution = odeint(modele_sir, y0, t, args=(beta, gamma))
    S, I, R = solution.T
    
    R0_epidemique = beta / gamma
    pic_infection = float(np.max(I))
    jour_pic = float(t[np.argmax(I)])
    
    return {
        "R0": round(R0_epidemique, 2),
        "pic_infectes": round(pic_infection),
        "jour_pic": round(jour_pic, 1),
        "total_touche": round(float(R[-1])),
        "pourcentage_population": round(float(R[-1]) / population * 100, 1),
        "t": t,
        "S": S,
        "I": I,
        "R": R
    }

Calibrer quand personne n’a publié les vrais paramètres

C’est ici que la simulation de Corrupted Blood devient un exercice honnête plutôt qu’une reconstitution. Blizzard n’a jamais publié les statistiques du sort : ni le rayon de transmission, ni la probabilité de contagion par tick, ni la durée de l’effet. Aucune valeur de bêta ne peut donc être présentée comme celle du bug.

Ce qu’on peut faire, et qui a plus de valeur pédagogique, c’est faire varier le rapport entre les deux paramètres et regarder ce qui bascule. Le rapport bêta sur gamma est le nombre de reproduction R0, et c’est lui qui décide de tout.

BETA = 0.9
GAMMA = 0.35

resultat = simuler_epidemie(
    population=10_000,
    infectes_initiaux=10,
    beta=BETA,
    gamma=GAMMA,
    jours=120
)

print(f"R0                        : {resultat['R0']}")
print(f"Pic d'infections          : {resultat['pic_infectes']:,} joueurs")
print(f"Jour du pic               : jour {resultat['jour_pic']}")
print(f"Population totale touchée : {resultat['pourcentage_population']}%")

Lire les courbes : ce que le pic raconte

Voici ce que produit ce code sur une population de 10 000 joueurs avec 10 infectés au départ, en faisant varier le seul rapport qui compte. Ces chiffres sortent de l’exécution du modèle, pas d’une source externe, et tu peux les reproduire en changeant les deux constantes.

Trois choses sautent aux yeux, et ce sont exactement celles qui ont rendu Corrupted Blood incontrôlable.

Le seuil est brutal. Entre R0 = 0,86 et R0 = 1,43, il n’y a pas un facteur d’aggravation, il y a un changement de nature. En dessous de 1, l’épidémie s’éteint toute seule et touche moins de 1% de la population. Au dessus, elle parcourt la moitié du serveur.

Le pic arrive d’autant plus tôt qu’il est haut. La contagion forte culmine au jour 13, la moyenne au jour 36. C’est le pire scénario pour qui doit réagir : plus la situation est grave, moins on a de temps pour la comprendre. Blizzard a mis plusieurs jours à identifier les vecteurs, ce qui, à l’échelle du modèle, arrive après le pic.

Presque tout le monde y passe, mais jamais tout le monde. Même à R0 = 2,57, environ 10% de la population n’est jamais touchée. Ce n’est pas de la chance, c’est mécanique : quand les infectés guérissent plus vite qu’ils ne trouvent des susceptibles à contaminer, la chaîne se rompt d’elle même.

Ce que le modèle SIR ne sait pas faire

Trois hypothèses sont câblées dans ces équations, et les trois sont fausses dans la vraie vie comme dans WoW.

• Le mélange est homogène. Chaque susceptible a la même probabilité de croiser chaque infecté. Dans WoW, la population était concentrée dans deux villes et les zones de bas niveau n’avaient presque aucun contact avec le raid.
• Les paramètres sont constants. Bêta ne bouge pas au cours de l’épidémie. Or dès que les joueurs ont compris ce qui se passait, ils ont changé de comportement, donc bêta a changé.
• La population est fermée. Personne n’entre, personne ne sort. C’est précisément l’inverse de ce qui a causé la propagation : les familiers mis en veille et les téléportations étaient des sorties et des entrées.

C’est pour ça que l’incident a intéressé les chercheurs. Il ne validait pas le modèle SIR, il exhibait ce que le modèle SIR laisse de côté.

Modèle avec comportements hétérogènes : ce que WoW a ajouté

Le vrai apport de l’incident Corrupted Blood était d’ajouter des comportements hétérogènes au modèle uniforme.

import random

class JoueurWoW:
    def __init__(self, id: int, niveau: int, type_comportement: str):
        self.id = id
        self.niveau = niveau
        self.etat = "susceptible"
        self.type_comportement = type_comportement
    
    @property
    def resistance(self) -> float:
        return min(0.95, self.niveau / 60)

def simuler_propagation_avec_comportements(
    population: list,
    jours: int,
    beta_base: float
) -> dict:
    """Simulation agent-based qui tient compte des comportements individuels."""
    stats_quotidiennes = []
    
    for jour in range(jours):
        infectes = [j for j in population if j.etat == "infecte"]
        susceptibles = [j for j in population if j.etat == "susceptible"]
        
        nouvelles_infections = 0
        nouvelles_guerisons = 0
        
        for susceptible in susceptibles:
            modificateur = {
                "curieux": 1.5,
                "prudent": 0.3,
                "soignant": 2.0,
                "neutre": 1.0
            }.get(susceptible.type_comportement, 1.0)
            
            beta_effectif = beta_base * modificateur * (1 - susceptible.resistance)
            
            if infectes and random.random() < beta_effectif * len(infectes) / len(population):
                susceptible.etat = "infecte"
                nouvelles_infections += 1
        
        for infecte in infectes:
            if random.random() < 0.1:
                infecte.etat = "retabli"
                nouvelles_guerisons += 1
        
        stats_quotidiennes.append({
            "jour": jour,
            "susceptibles": len([j for j in population if j.etat == "susceptible"]),
            "infectes": len([j for j in population if j.etat == "infecte"]),
            "retablis": len([j for j in population if j.etat == "retabli"]),
        })
    
    return stats_quotidiennes

# Population hétérogène
random.seed(42)
population_wow = []
comportements = ["curieux", "prudent", "soignant", "neutre"]
poids = [0.2, 0.4, 0.1, 0.3]

for i in range(1000):
    niveau = random.randint(1, 60)
    comportement = random.choices(comportements, weights=poids)[0]
    j = JoueurWoW(i, niveau, comportement)
    if i < 3:
        j.etat = "infecte"
    population_wow.append(j)

stats = simuler_propagation_avec_comportements(population_wow, jours=21, beta_base=0.3)
pic = max(stats, key=lambda x: x["infectes"])
print(f"\nSimulation agent-based :")
print(f"Pic d'infections : {pic['infectes']} joueurs au jour {pic['jour']}")

---

Ce que les comportements des joueurs ont appris aux chercheurs

L’article de Balicer et les travaux qui ont suivi ont identifié plusieurs comportements observés dans WoW qui correspondaient à des comportements humains documentés en épidémiologie réelle.

La fuite amplifie la propagation géographique. Les joueurs qui fuyaient les zones infectées transportaient parfois le virus vers de nouvelles zones avant d’en mourir. C’est exactement le mécanisme qui a propagé le SRAS en 2003 via les voyages aériens.

Les soignants s’exposent davantage. Dans WoW, les joueurs de classe soignante s’approchaient des zones infectées pour tenter de guérir d’autres joueurs. Leur taux d’infection était significativement plus élevé que la moyenne. Ce comportement correspond aux taux d’infection élevés chez les personnels de santé en épidémie réelle.

Un sous-groupe ignore systématiquement les avertissements. Même avec des messages d’alerte dans le chat du jeu, une fraction des joueurs entrait délibérément dans les zones contaminées. Ce comportement de non-conformité était quantifiable dans les logs. En épidémiologie réelle, ce sous-groupe correspond aux personnes qui ne respectent pas les mesures de distanciation.

Ce que WoW a permis que les modèles classiques ne permettaient pas : observer ces comportements sur des milliers de sujets, avec des logs complets, dans une épidémie qui commençait à un moment connu avec des paramètres initiaux connus.

---

Questions fréquentes

Qu’est-ce que l’incident Corrupted Blood dans World of Warcraft ?

En septembre 2005, un sort de boss dans WoW appelé « Corrupted Blood » s’est répandu hors de la salle du raid prévue via des familiers de joueurs et des téléportations. Il a infecté des milliers de joueurs dans les zones peuplées du jeu, tuant les personnages bas niveau en quelques secondes. Blizzard a mis plusieurs jours à résoudre l’incident, qui est devenu un cas d’étude en épidémiologie computationnelle.

Pourquoi des épidémiologistes ont-ils étudié un bug de jeu vidéo ?

Parce que l’incident a produit une simulation accidentelle de pandémie avec des comportements humains réels. Les chercheurs y ont observé des phénomènes difficiles à modéliser théoriquement : fuite des zones infectées, altruisme des soignants, non-conformité aux avertissements. Ces comportements correspondent à des comportements documentés en épidémiologie réelle et ont été cités dans des travaux de modélisation du Covid-19.

Qu’est-ce que le modèle SIR en épidémiologie ?

Le modèle SIR divise une population en Susceptibles, Infectés et Rétablis, ces derniers immunisés ou décédés. Deux paramètres clés le gouvernent : bêta, le taux de transmission, et gamma, le taux de guérison. Leur ratio donne le R0, le nombre de reproduction de base : si R0 > 1, l’épidémie se propage ; si R0 < 1, elle s’éteint. C’est le modèle de base utilisé par les épidémiologistes pour estimer l’évolution d’une épidémie.

Comment Python est-il utilisé en épidémiologie computationnelle ?

Python, avec les bibliothèques NumPy, SciPy et Matplotlib, est l’un des environnements les plus utilisés pour la modélisation épidémique. scipy.integrate.odeint permet de résoudre les équations différentielles du modèle SIR. Des modèles plus complexes comme les simulations agent-based utilisent des classes Python pour représenter des individus avec des comportements hétérogènes, comme dans la simulation Corrupted Blood de cet article.

Le modèle SIR sert-il à autre chose qu’aux épidémies ?

Oui, et c’est ce qui le rend intéressant pour un dev. La même équation décrit toute diffusion par contact dans une population finie : la propagation d’une rumeur, l’adoption d’une fonctionnalité par bouche à oreille, la contamination d’un cache par une valeur corrompue, la viralité d’un contenu. Les trois compartiments changent de nom, la dynamique reste la même, et le seuil de R0 égal à 1 sépare toujours ce qui s’éteint de ce qui se répand.

Le bug Corrupted Blood a-t-il influencé la réponse au Covid-19 ?

Des chercheurs ont cité l’incident WoW dans des publications sur la modélisation comportementale en pandémie, notamment pour la compréhension de la non-conformité aux mesures sanitaires et de la propagation géographique via les voyages. L’influence directe sur les politiques de santé publique reste difficile à quantifier, mais l’incident a contribué à légitimer les environnements virtuels comme outils de recherche épidémiologique.

---

Des bugs comme miroirs du monde réel

Le Corrupted Blood n’était pas un bug dangereux. Personne n’est mort. Des pixels ont disparu de l’écran.

Mais il a accidentellement recréé quelque chose de vrai : la façon dont les humains se comportent face à une menace invisible et contagieuse. Avec leurs forces, leurs faiblesses, leurs altruismes et leurs irresponsabilités.

Ce que les jeux vidéo font mieux que n’importe quel modèle théorique, c’est qu’ils mettent de vrais gens dans des situations simulées et enregistrent ce qu’ils font vraiment. Pas ce qu’ils disent qu’ils feraient. Ce qu’ils font.

En 2020, quand le Covid-19 a commencé à se propager, plusieurs chercheurs avaient déjà un modèle de ce à quoi ressemblait une propagation virale avec des comportements humains réels. Ils l’avaient vu dans un raid WoW en 2005.

Les bugs les plus intéressants ne sont pas ceux qui cassent. Ce sont ceux qui révèlent.

Et la prochaine fois qu’un comportement bizarre remonte de ta production, pose toi la question de Blizzard : est-ce que c’est un bug isolé, ou est-ce que quelque chose se propage ?

Dernière mise à jour : juin 2026

Cet article fait partie de la série 10 bugs informatiques qui ont tué, crashé et coûté des milliards.