Angon Cloud
Angon CloudDocs
Autres moteursMulti-moteurs

Sans GDevelop : SDK JS & autres moteurs

SDK angon.js autonome et API REST pour PixiJS, Phaser, Unity, Godot ou du JavaScript pur — panneaux préconfigurés inclus.

Angon Cloud n'est pas réservé à GDevelop : un SDK JavaScript autonome (angon.js) embarque tout ce que fait l'extension — authentification, panneaux de connexion et de matchmaking, tables, fichiers, matchmaking, salons temps réel — utilisable depuis PixiJS, Phaser, Three.js ou du vanilla JavaScript. Pour les moteurs natifs (Godot, Unity, Unreal), l'API REST reste disponible.
Pour vos agents IA
Toute la documentation est disponible en texte brut pour les outils IA : /llms.txt (index, convention llmstxt.org) et /llms-full.txt (référence complète : SDK, REST, catalogue des fonctions GDevelop). Donnez simplement l'URL https://angonstudio.cloud/llms-full.txt à votre IA pour qu'elle connaisse toute l'API.

1. Le SDK angon.js — une balise script

Le fichier angon.js est servi à la racine de votre console Angon. Copiez-le dans votre projet (ou référencez-le en direct) : zéro dépendance, ~180 Ko, assets et styles embarqués.

index.html
<script src="https://angonstudio.cloud/angon.js"></script>
<!-- ou : <script src="./angon.js"></script> si vous copiez le fichier -->
Démarrage
// Récupérez votre clé dans l'onglet API du jeu (console Angon)
const loggedIn = await Angon.init({
  apiKey: "sk_live_VOTRE_CLE",
  // baseUrl: "https://votre-console/api/public/v1", // optionnel
  // container: document.getElementById("ui"),        // optionnel, défaut: body
});

// Panneau de connexion préconfiguré — même habillage que votre tableau de bord
if (!loggedIn) {
  Angon.panels.login({ onClose: () => demarrerJeu() });
} else {
  demarrerJeu(); // session restaurée depuis localStorage
}
Les panneaux sont inclus
Angon.panels.login() et Angon.panels.openMatchmaking("2v2") affichent exactement les panneaux de votre console : couleurs, police, logo, textes personnalisés (servis via GET /panel). Ce sont des overlays HTML au-dessus de votre canvas — pas besoin de recréer l'UI.

Si vous passez container à init, les panneaux s'affichent dans cet élément au lieu de document.body — donnez-lui position: relative pour qu'ils recouvrent juste votre canvas.

2. Ce que le SDK expose

ModuleMéthodes principales
Angon.authlogin, register, loginWithGoogle, logout, restore, me, uploadAvatar
Angon.panelslogin, signup, close, openMatchmaking, closeMatchmaking
Angon.matchmakingjoin(mode), leave, status, onStatus(cb)
Angon.roomjoin(partieId), leave, send(obj), onMessage(cb), isConnected
Angon.storageupload, uploadFile(File), pickFile, list, remove
Angon.tableslist, get, create, update, remove, syncPending (offline inclus)
Angon.leaderboardssubmit(code, valeur), fetch(code, limit)
Angon.shoparticles()

L'état courant est lisible en direct dans Angon.state (loggedIn, pseudo, avatarUrl, mmStatus, mmPartieId, mmCodeSalon…), et Angon.onAuthChange(cb) notifie les connexions/déconnexions.

3. Exemple concret : PixiJS

Flux complet — login avec le panneau préconfiguré, sauvegarde Drive, score, matchmaking et salon temps réel — autour de votre boucle de jeu :

game.js — PixiJS + angon.js
const app = new PIXI.Application();
await app.init({ resizeTo: window });
document.body.appendChild(app.canvas);

// 1. Panneau de connexion (thème de votre console, localStorage inclus)
await Angon.init({ apiKey: "sk_live_VOTRE_CLE" });
if (!Angon.state.loggedIn) {
  await new Promise((ok) => Angon.panels.login({ onClose: ok }));
}

// 2. Sauvegarde JSON -> Google Drive
await Angon.storage.upload(
  "sauvegarde.json",
  JSON.stringify({ niveau: 5, score: 1500 }),
  "application/json"
);

// 3. Score vers un classement
await Angon.leaderboards.submit("course_infinie", 1500);

// 4. Matchmaking avec le panneau intégré (recherche + écran VS)
Angon.matchmaking.onStatus(({ status, partieId, codeSalon, participants }) => {
  if (status === "matched") {
    // participants = [{ pseudo, avatar, equipe, ... }]
    Angon.room.join(partieId); // ferme le panneau une fois connecté
  }
});
Angon.panels.openMatchmaking("2v2");

// 5. Actions temps réel dans le salon
Angon.room.onMessage((payload) => appliquerCoupAdverse(payload));
Angon.room.send({ x: sprite.x, y: sprite.y });

4. Alternative : l'API REST directement

Le SDK n'est qu'une enveloppe autour de l'API REST publique. Pour un contrôle total, un moteur natif, ou un backend serveur, appelez les endpoints directement avec deux en-têtes :

En-têteRôleQuand
x-api-keyIdentifie votre jeu (clé sk_live_…)Toutes les requêtes
x-player-tokenSession du joueur (jeton pt_…)Actions d'un joueur connecté
angon-client.js — client REST minimal (~40 lignes)
const Angon = {
  baseUrl: "https://angonstudio.cloud/api/public/v1",
  apiKey: "sk_live_VOTRE_CLE",
  token: localStorage.getItem("angon_token") || "",

  async call(path, method = "GET", body = null) {
    const res = await fetch(this.baseUrl + path, {
      method,
      headers: {
        "Content-Type": "application/json",
        "x-api-key": this.apiKey,
        ...(this.token ? { "x-player-token": this.token } : {}),
      },
      body: body ? JSON.stringify(body) : undefined,
    });
    const json = await res.json().catch(() => null);
    return { ok: res.ok, status: res.status, json };
  },

  async login(email, password) {
    const r = await this.call("/players/login", "POST", { email, password });
    if (r.ok && r.json?.token) {
      this.token = r.json.token;
      localStorage.setItem("angon_token", this.token); // session persistante
    }
    return r;
  },

  logout() {
    this.token = "";
    localStorage.removeItem("angon_token");
  },
};

5. Multijoueur temps-réel sans le SDK

Angon.room parle déjà le protocole WebSocket Phoenix — sans dépendance. Si vous écrivez votre propre client, les salons utilisent Supabase Realtime Broadcast : récupérez la configuration via GET /realtime/config, puis abonnez-vous au canal angon_partie_<partie_id> :

Salon temps-réel avec supabase-js
import { createClient } from "@supabase/supabase-js";

// 1. Config publique (url + clé anon) de votre backend
const cfg = (await Angon.call("/realtime/config")).json;
const supabase = createClient(cfg.url, cfg.key);

// 2. Canal du salon : angon_partie_<partie_id> (partie_id vient du matchmaking)
const channel = supabase.channel(cfg.channel_prefix + partieId);

channel.on("broadcast", { event: "action" }, ({ payload }) => {
  appliquerCoupAdverse(payload); // ex: déplacer un sprite PixiJS
});

await channel.subscribe();
channel.send({ type: "broadcast", event: "action", payload: { x: 3, y: 7 } });
Moteurs natifs (Godot, Unity, Unreal)
Le broadcast Supabase utilise le protocole WebSocket Phoenix. En dehors du JS, utilisez un client Phoenix WebSocket de votre moteur, ou un polling via GET /matchmaking/status et les tables pour synchroniser l'état de la partie.

6. Ce qui est prêt vs ce qu'il faut porter

FonctionnalitéNavigateur JS (PixiJS, Phaser…)Natif (Godot, Unity…)
Auth, tables, fichiers Drive, classements, boutique, matchmakingPrêt — angon.js ou fetchPrêt — client HTTP
Panneaux de connexion / matchmakingPrêt — Angon.panels (thème console)À recréer en UI native (GET /panel pour le thème)
Session persistantePrêt — localStorage automatiqueStockage natif du moteur
Temps réel des salonsPrêt — Angon.room (Phoenix WS embarqué)Client WebSocket Phoenix
File picker (upload appareil)Prêt — Angon.storage.pickFileDialogue natif du moteur
Liste complète des endpoints
Chaque paramètre et chaque format de réponse est détaillé dans la Référence API REST. Le serveur répond du JSON standard avec des codes d'erreur uniformes (missing_key, missing_player, upload_failed…).