- En 2005, un sort de WoW s'est propagé hors de sa zone via les familiers mis en veille et les téléportations de joueurs infectés, créant une épidémie virale simulée par accident.
- Des épidémiologistes ont analysé les logs de Blizzard et y ont trouvé des comportements humains réels face à une pandémie que leurs modèles théoriques prédisaient.
- Le modèle SIR (Susceptible-Infected-Recovered) se reproduit en Python avec scipy en une vingtaine de lignes.
- Les comportements observés dans le jeu (fuite, altruisme, soignants qui s'approchent) correspondaient aux prédictions théoriques des modèles épidémiques.
- Un bug de jeu vidéo a fourni à la science des données qu'aucune expérience éthique n'aurait pu produire en conditions réelles.
Lecture complète : 14 min
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
En 2007, Ran Balicer, épidémiologiste israélien, a publié un article dans la revue Epidemiology intitulé “Modeling Infectious Diseases Dissemination Through Online Role-Playing Games”. La thèse centrale : l’incident Corrupted Blood était une simulation accidentelle de pandémie avec des sujets humains réels qui réagissaient avec leurs propres comportements.
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 : la base de l’épidémiologie computationnelle
Le modèle SIR divise une population en trois compartiments : Susceptibles (pas encore infectés), Infectés (actuellement contagieux), et Rétablis (immunisés ou décédés). Deux paramètres gouvernent la dynamique : le taux de transmission bêta (probabilité qu’un susceptible devienne infecté au contact d’un infecté) et le taux de guérison gamma (probabilité qu’un infecté se rétablisse par unité de temps).
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
}Reproduire Corrupted Blood en Python
Le bug WoW avait des paramètres spécifiques. Blizzard n’a jamais publié les stats exactes du sort, mais les estimations des chercheurs permettent de calibrer une simulation raisonnable.
import numpy as np
from scipy.integrate import odeint
BETA_CORRUPTED_BLOOD = 0.35
GAMMA_CORRUPTED_BLOOD = 0.15
resultat_wow = simuler_epidemie(
population=50_000,
infectes_initiaux=5,
beta=BETA_CORRUPTED_BLOOD,
gamma=GAMMA_CORRUPTED_BLOOD,
jours=14
)
print("=== Simulation Corrupted Blood (1 serveur WoW) ===")
print(f"R0 (nombre de reproduction) : {resultat_wow['R0']}")
print(f"Pic d'infections : {resultat_wow['pic_infectes']:,} joueurs")
print(f"Jour du pic : Jour {resultat_wow['jour_pic']}")
print(f"Population totale touchée : {resultat_wow['total_touche']:,} ({resultat_wow['pourcentage_population']}%)")
# Comparaison avec des épidémies réelles
print("\n=== Comparaison avec des épidémies réelles ===")
grippe = simuler_epidemie(100_000, 10, beta=0.5, gamma=0.33, jours=90)
print(f"Grippe saisonnière - R0: {grippe['R0']}, pic jour {grippe['jour_pic']}, touchés: {grippe['pourcentage_population']}%")
rougeole = simuler_epidemie(100_000, 1, beta=1.2, gamma=0.14, jours=180)
print(f"Rougeole - R0: {rougeole['R0']}, pic jour {rougeole['jour_pic']}, touchés: {rougeole['pourcentage_population']}%")
covid = simuler_epidemie(100_000, 10, beta=0.25, gamma=0.071, jours=365)
print(f"Covid-19 (sans mesures) - R0: {covid['R0']}, pic jour {covid['jour_pic']}, touchés: {covid['pourcentage_population']}%")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 (ou décédés). Deux paramètres clés le gouvernent : bêta (taux de transmission) et gamma (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 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 toi, ton copywriting révèle quoi à ton lecteur ? Lance un audit gratuit sur copyboost.io pour le découvrir.
Dernière mise à jour : mai 2026
Cet article fait partie de la série 10 bugs informatiques qui ont tué, crashé et coûté des milliards.
Discussion