ForHosting KIT · Outils pour développeurs

Mélanger un jeu avec une graine

Ce mélangeur à graine transforme un entier en un ordre précis des 52 cartes d’un jeu standard.

● BetaGratuit · dans votre navigateur
Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

En réutilisant la même graine, vous obtenez le même ordre, ce qui facilite l’analyse et le partage de simulations, de tests, d’exercices et de parties reproductibles. Le résultat emploie des codes courts pour les valeurs et les couleurs, contient chaque carte une seule fois et ne dépend ni du réseau, ni de l’heure, ni d’un aléa caché. Des graines différentes donnent généralement des ordres différents tout en conservant la même procédure documentée.

Obtenez un mélange répétable avec un seul entier

Saisissez un entier dans le champ <code>seed</code>. La capacité construit d’abord un jeu standard de 52 cartes dans un ordre canonique fixe : piques, cœurs, carreaux et trèfles, chaque couleur allant de l’as au roi. Elle applique ensuite une suite pseudo-aléatoire issue de la graine à un mélange de Fisher-Yates. Toutes les données du procédé étant fixes, l’ordre obtenu l’est également. La graine 42 produit aujourd’hui exactement la même réponse que lors d’une autre requête, dans un autre environnement ou pendant une autre exécution de test. Cette répétabilité constitue l’objectif essentiel de l’outil. Un développeur peut ainsi placer un jeu mélangé dans un fixture sans stocker 52 valeurs, un enseignant peut distribuer un exercice commun et un jeu peut enregistrer la graine permettant de reconstruire la donne initiale. La réponse restitue aussi la graine afin que les résultats sauvegardés restent explicites. Seuls les entiers JSON sûrs sont admis ; les décimales, chaînes numériques, valeurs absentes, infinis et entiers hors de la plage exacte de JavaScript sont refusés sans arrondi silencieux.

Interprétez correctement l’ordre renvoyé

Le tableau <code>deck</code> contient exactement 52 chaînes distinctes dans l’ordre de tirage. Chaque chaîne associe une valeur à un code de couleur d’une lettre. Les valeurs sont <code>A</code>, de <code>2</code> à <code>10</code>, <code>J</code>, <code>Q</code> et <code>K</code>. Les couleurs utilisent <code>S</code> pour pique, <code>H</code> pour cœur, <code>D</code> pour carreau et <code>C</code> pour trèfle. Ainsi, <code>AS</code> désigne l’as de pique et <code>10D</code> le dix de carreau. Le premier élément est la carte supérieure, suivi de la deuxième carte à tirer, puis des suivantes. La capacité ne distribue pas les mains, n’ajoute pas de jokers, n’évalue pas les combinaisons de poker et ne modifie pas l’ordre après l’avoir renvoyé. Ces choix reviennent à l’application appelante. Pour donner cinq cartes à quatre joueurs, par exemple, consommez les vingt premières entrées selon votre méthode de distribution. Ce résultat simple et explicite n’impose aucune règle de table et permet de copier, comparer, sérialiser ou transmettre facilement la permutation complète à un simulateur.

Employez un mélange déterministe à bon escient

Un mélange déterministe vise la reproductibilité, et non le secret. Toute personne connaissant la graine et l’algorithme peut reconstruire le jeu entier. Cette capacité convient donc aux tests, démonstrations, simulations, énigmes à graine publiée et jeux où la possibilité de rejouer importe davantage que la dissimulation de l’état. Ne l’utilisez pas pour des paris, des récompenses, des décisions de sécurité ou toute situation où prévoir les prochaines cartes créerait un avantage. Préférez alors une source aléatoire cryptographiquement sûre dont l’état reste confidentiel. Dans son domaine prévu, la graine simplifie fortement le diagnostic : joignez-la au rapport d’un test défaillant, reproduisez localement la même donne et comparez le comportement carte après carte. Vous pouvez aussi lancer des séries de graines consécutives pour obtenir des scénarios stables sans versionner de gros fichiers de fixtures. L’implémentation n’utilise ni réseau, ni horloge, ni état global mutable, ni <code>Math.random</code>, ni données externes. La définition fixe du jeu et les 51 échanges bornés rendent l’exécution et le résultat faciles à contrôler.

Reproduire un défaut de jeu

Conservez la graine dans le rapport d’erreur, puis recréez le même jeu initial pour examiner la distribution ou le score.

Créer des fixtures de test stables

Générez des ordres mélangés réalistes qui restent identiques en local et dans l’intégration continue.

Partager une simulation pédagogique

Donnez la même graine à chaque participant afin que les exercices de probabilité commencent avec un jeu identique.

Quel est le coût d’une requête ?

Le tarif de l’API est de $0.002 par requête ; le même mélange déterministe peut aussi s’exécuter gratuitement dans le navigateur.

Une même graine renvoie-t-elle toujours le même jeu ?

Oui. La construction, le générateur pseudo-aléatoire et les étapes du mélange sont fixes ; toute graine admise reproduit donc le même ordre.

Quelles cartes sont incluses ?

Le résultat comprend les 52 cartes standard de pique, cœur, carreau et trèfle, sans joker.

Pourquoi ma graine a-t-elle été refusée ?

Elle doit être un entier JSON dans la plage exacte sûre. Les décimales, chaînes, valeurs absentes et entiers trop grands sont invalides.

Ce mélange convient-il aux paris ou à la sécurité ?

Non. Il est volontairement reproductible et donc prévisible par toute personne connaissant la graine et l’algorithme.

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

POSThttps://api.kit.forhosting.com/game/card-deck-shuffle-seeded

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

curl -X POST https://api.kit.forhosting.com/game/card-deck-shuffle-seeded \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"seed":42}'
{
  "seed": 42
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "game.card_deck_shuffle_seeded",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

HTTPCodeSignification
401unauthorizedClé API absente ou invalide : vérifiez l’en-tête Authorization.
402insufficient_balanceSolde insuffisant : rechargez votre compte pour lancer cette tâche.
404unknown_typeType de tâche inconnu : vérifiez le champ type de votre requête.
429rate_limitedTrop de requêtes : ralentissez la cadence, puis réessayez.

Consulter la documentation complète du KIT →