La boucle de jeu reste masquée
Les créateurs par glisser-déposer masquent la boucle de rendu et le minutage, donc un score sur mesure, un rythme de manches et des animations reviennent à lutter contre l’outil au lieu de modifier la boucle.
Générateur de jeu pour prototypes web jouables
Transformez une idée de jeu en un build web que vous jouez et inspectez
Décrivez le jeu, les manches et la façon dont les joueurs s’affrontent. E-Code en fait une boucle modifiable, une interface de salon, des règles de score et un modèle d’état multijoueur. Jouez le parcours local dans l’aperçu, affinez-le avec l’Agent, puis connectez un service temps réel avant d’inviter des joueurs distants.
Partez du jeu que vous avez déjà en tête. Les fichiers source, l’aperçu actif et les contrôles de publication restent visibles à mesure que le jeu évolue.
Manche 3 sur 5
Quelle capitale se trouve sur le détroit du Bosphore ?
Un concept de quiz responsive qui présente un salon, des questions chronométrées et une interface de score partagé dans une boucle de manches claire.
Classement en direct
- NadiaEn tête
- Marco
- Priya
Cette démonstration intégrée présente un classement en direct, le panneau de la question en cours et un contrôle de réponse dans une mise en page responsive.
Du carcan du moteur à une boucle de jeu inspectable
Les créateurs de jeu paraissent simples jusqu’à ce que l’état multijoueur et le test en jeu se heurtent à l’outil
Un jeu de quiz en direct a besoin d’une boucle serrée : un salon qui se remplit, des questions qui se déclenchent en synchronie et un classement qui se met à jour pour tout le monde en même temps. Les outils no-code démarrent vite, puis masquent la boucle de jeu et le réseau, et l’export correspond rarement à un code que l’équipe peut faire évoluer.
L’état multijoueur se désynchronise
Quand chaque client suit son propre score et son propre chrono, les joueurs voient des classements différents, et aucune source unique n’est inspectable, versionnable et raisonnée par l’équipe.
Vous ne pouvez pas vraiment le tester en jeu
Prévisualiser un écran n’est pas jouer une partie. Sans jeu actif ni vraies manches, les bugs de minutage et les cas limites n’apparaissent qu’une fois les joueurs en ligne.
E-Code part du jeu que vous décrivez et produit une boucle web, des règles et un modèle d’état multijoueur modifiables dans les fichiers source. Vous testez le parcours local dans l’aperçu, branchez le réseau aux endroits exposés par le code et demandez le changement suivant sans quitter le projet.
Un prompt lance le jeu
Décrivez les manches, pas le moteur
La demande ci-dessous se lit comme un mot d’un concepteur de jeu. Les quatre éléments cartographient son périmètre d’implémentation dans de vrais fichiers source, pas un moteur verrouillé.
Exemple de prompt
Crée un jeu de quiz multijoueur avec score en temps réel et classement.
- 01
Boucle de jeu sur canvas
Une vraie boucle de rendu et de mise à jour anime les manches, les chronos et les animations sur desktop, tablette et mobile à partir de composants modifiables.
- 02
Modèle d’état multijoueur
Les états du salon, de la question, du chrono et du classement vivent dans un code modifiable avec des points de branchement explicites pour un backend temps réel. La synchronisation distante ne démarre qu’une fois ce service connecté.
- 03
Score et manches
Le traitement des réponses, le score par manche et les conditions de victoire sont modélisés comme de vraies règles de jeu plutôt qu’un écran statique.
- 04
Aperçu et publication
E-Code exécute le parcours local dans l’aperçu à toutes les tailles d’écran. Les frontends statiques pris en charge suivent la publication guidée ; les parties distantes exigent toujours le service temps réel que vous connectez.
De l’instruction en langage courant à l’aperçu actif
Découvrez la boucle IDE derrière une construction E-Code
La page App Builder montre un vrai workspace E-Code capturé — le prompt, le plan de l’agent, les fichiers générés et l’aperçu actif — pour une application de réservation. La même boucle de construction s’applique à un jeu interactif comme celui-ci.
Le run salon capturé réunit le prompt utilisateur, le plan de l’Agent, les fichiers modifiables et l’application active sur un même écran — les mêmes surfaces qui servent à construire et tester un jeu web.
Ouvrir la capture IDE du run salon en pleine résolution
Ce vrai suivi formule une erreur en langage courant pour que l’Agent inspecte le code, préserve les routes fonctionnelles et vérifie à nouveau l’aperçu.
Ouvrir la capture IDE du run salon en pleine résolutionCe que vous recevez
Une base de jeu jouable que vous inspectez et faites évoluer
Le projet reste inspectable du premier fichier généré jusqu’à l’aperçu et l’export. Les builds statiques pris en charge ajoutent une mise en ligne guidée sans masquer le code.
Un code de jeu ouvert et exportable
La boucle de rendu, les règles de manche, les composants d’interface, l’état et les styles restent lisibles, versionnables et transportables hors d’E-Code.
Un adaptateur d’état de partie, pas un serveur caché
Les états du salon, de la question, du chrono et du classement apparaissent dans la source. Branchez ce modèle à un backend temps réel avant d’attendre une synchronisation entre joueurs distants.
Un aperçu jouable à chaque format cible
Exécutez le parcours local des manches dans l’aperçu actif et testez les contrôles et le classement sur desktop, tablette et mobile.
Publication guidée du frontend statique
Les builds statiques de jeu pris en charge suivent le parcours de mise en ligne E-Code quand le test en jeu est prêt à être partagé.
Un lien de test en ligne avec une frontière serveur claire
Un frontend statique pris en charge se publie sur une URL E-Code. Les jeux qui dépendent d’un serveur restent exportables afin de déployer ensemble le frontend et le runtime connecté.
Réglez la manche suivante avec l’Agent
Demandez une nouvelle règle de score, un chrono plus court ou un autre type de question, puis jouez le parcours local mis à jour sans recréer le projet.
Pensé pour de vrais jeux dans le navigateur
La boucle, les règles et les écrans du jeu web dans un code que vous maîtrisez
Le parcours Générateur de jeu garde la logique, l’état prêt à connecter et la publication du frontend dans un seul flux inspectable.
Canvas et boucle de jeu
Une vraie boucle de rendu et de mise à jour pour les manches, chronos et animations que vous réglez.
Multijoueur prêt à connecter
Un salon et un état de partie avec les points d’intégration du service qui synchronise les joueurs distants.
Score et manches
Traitement des réponses, score par manche et conditions de victoire modélisés comme des règles de jeu.
Test en jeu dans l’aperçu
Jouez le parcours local dans l’aperçu à toutes les tailles d’écran avant de publier.
Responsive par défaut
Les écrans de jeu s’adaptent du grand écran au téléphone sans build mobile séparé.
Gardez la source accessible
Exportez le projet ou publiez les frontends statiques pris en charge tout en conservant des fichiers source modifiables.
Qui construit avec
Les jeux que les équipes livrent avec le Générateur de jeu
D’une soirée quiz en direct à un défi en classe, la même boucle produit un vrai jeu jouable.
Quiz et trivia multijoueur
Parcours de salon, questions chronométrées et score partagé prêts à brancher à un service de partie temps réel.
Jeux en classe et formation
Interfaces de défis interactifs avec règles de score et classement prêt pour des données synchronisées.
Jeux d’événement et campagne
Frontends de jeux de marque avec salons et classements à brancher à l’infrastructure de l’événement.
Expériences arcade casual
Jeux sur canvas avec boucle de jeu, gestion des entrées et suivi du score.
Questions fréquentes
Le Générateur de jeu, en toute honnêteté
Ce que produit le parcours Générateur de jeu, et où sont ses limites.
J’obtiens du vrai code ou un moteur verrouillé ?+
Vous obtenez des fichiers source modifiables — composants, boucle de jeu, état et styles — que vous lisez, versionnez et exportez. Aucun verrouillage propriétaire de moteur.
Le multijoueur est-il réel ?+
Pas dans la démonstration intégrée : elle utilise des données de partie fictives et aucun backend connecté. La source générée peut modéliser le salon et l’état de partie, mais les joueurs distants exigent un service temps réel que vous connectez, sécurisez et testez.
Puis-je tester le jeu avant de publier ?+
Oui. E-Code exécute le parcours local des manches dans l’aperçu sur desktop, tablette et mobile. Le test d’une partie distante commence après le branchement du service réseau.
Puis-je connecter un backend temps réel ou une base ?+
Le modèle d’état généré est du code que vous étendez et branchez à des services externes. La démonstration intégrée de cette page utilise des données fictives et aucun backend connecté.
Comment modifier le jeu ensuite ?+
Modifiez les fichiers directement ou demandez le changement suivant à l’Agent et relisez le diff face à l’aperçu actif.
Générateur de jeu pour prototypes web jouables
Décrivez votre jeu et jouez ses premières manches
Transformez le jeu que vous avez en tête en une boucle web, un salon et un système de score modifiables, testez le parcours local dans l’aperçu, puis connectez le service qui anime les parties distantes.