Un événement asynchrone est déclenché lorsque GameMaker Studio 2 reçoit un "rappel" d'une source externe, qui peut provenir du Web ou de l'appareil qui exécute votre partie. Fondamentalement, vous dites à GameMaker Studio 2 de faire quelque chose, comme charger une image, et il va commencer à le faire, mais continuer à faire tout ce qu'il a à faire en attendant son fonctionnement. Ensuite, une fois la requête terminée, un rappel sera envoyé à GameMaker Studio 2 et tous les événements asynchrones définis pour ce type de rappel seront déclenchés. S'il vous plaît noter que les événements asynchrones sont déclenchés pour toutes les instances qui les ont, tout comme les événements clés, de sorte que vous pouvez faire un http_get appeler dans une instance, mais avoir l'événement HTTP asynchrone dans un autre pour traiter le rappel.
REMARQUE: vous devez savoir qu'en raison de la protection XSS dans les navigateurs, les demandes et les tentatives de chargement de ressources à partir de plusieurs domaines sont bloquées et peuvent renvoyer des résultats vides lors de l'utilisation de l'un des événements suivants
Il existe différents types d'événements associés à la catégorie d'événement asynchrone, et ils sont tous expliqués dans les sections suivantes:
NOTE: La variable async_load qui est mentionné dans les sections suivantes n'est valable que pour ces événements, ds_map c'est-à-dire que les points sont créés au début de l'événement, puis de nouveau supprimés à la fin, cette variable étant réinitialisée à la valeur -1 à tous les autres moments.
Cet événement ne peut être déclenché que par les fonctions de lecture de la file d'attente audio. ds_map stocké dans la variable async_load, contenant différentes paires clé / valeur relatives à la file d'attente audio ayant déclenché l'événement. L'événement est déclenché lorsque vous avez sélectionné une file d'attente audio à lire et qu'un tampon dans cette file d'attente audio a fini de jouer.
Les clés suivantes seront disponibles dans le fichier ds_map:Comme une file d'attente audio peut être créée à partir de plusieurs tampons, cet événement peut être déclenché plusieurs fois pour une file d'attente lorsque la fin de chaque section d'audio bufférisée est atteinte, d'où la clé "buffer_id".
- " queue_id " - l'index de file d'attente de la file d'attente qui a fini de jouer, tel que renvoyé par la fonction audio_create_play_queue.
- " buffer_id " - l'identifiant du tampon qui n'est plus en cours de lecture
- " queue_shutdown " - ceci est mis à 0 pendant la lecture normale et à 1 quand l'événement est reçu parce que audio_free_play_queue a été appelé. Lorsque ce paramètre est défini sur 1, vous ne souhaitez pas mettre en attente d'autres données.
NOTE: La variable async_load n'est valide que dans les événements asynchrones, ds_map c'est-à-dire que les points sont créés au début de l'événement, puis supprimés à la fin, cette variable étant réinitialisée à la valeur -1. Cependant, toutes les autres structures de données créées à partir de l'événement doivent être nettoyées à l'aide des fonctions appropriées.
Dans l'exemple d'utilisation donné ci-dessous, nous allons créer une file d'attente audio avec 10 sons audio tamponnés, puis lire la file d'attente:audio_queue = audio_create_play_queue(buffer_s16, 11052, audio_mono);
for (var i = 0; i < 10; i++;)
{
audio_queue_sound(audio_queue, audio_buffer[i], 0, buffer_get_size(audio_buffer[i]));
}
audio_play_sound(audio_queue, 0, true);
Chaque étape du jeu maintenant que l'enregistrement est détecté déclenchera un événement d'enregistrement audio asynchrone où vous pourrez gérer quelque chose comme ceci:var queue = async_load[? "queue_id"];
var num = 0;
if queue = audio_queue
{
for (var i = 0; i < 10; i++;)
{
if async_load[? "buffer_id"] == audio_buffer[i]
{
buffer_seek(audio_buffer[i], buffer_seek_start, 0);
num = i;
}
}
if num == 9
{
audio_stop_sound(audio_queue);
audio_free_play_queue(audio_queue);
}
}
Ici, nous vérifions l'ID de la file d'attente et, si c'est celui que nous voulons, nous vérifions ensuite l'ID de la mémoire tampon pour voir quel tampon a été lu. Nous définissons ensuite un var local à cette valeur d'index pour le vérifier plus tard et remettons le tampon au début pour ce son. Une fois que notre variable locale atteint 9, indiquant que la file d'attente est terminée, nous arrêtons la lecture du son et libérons la file d'attente.
Cet événement ne peut être déclenché que par audio_start_recording() fonction et retournera un ds_map stocké dans la variable async_load, contenant différentes paires clé / valeur en fonction du rappel de la fonction qui a déclenché l'événement.
Les clés suivantes seront disponibles dans le fichier ds_map:
- " buffer_id " - l'identifiant du tampon temporaire que vous pouvez utiliser pour récupérer les données audio
- " channel_index " - l'index du canal d'enregistrement renvoyé par la fonction d'appel à laquelle proviennent ces données
- " data_len " - la longueur des données (en octets) que vous avez reçues
NOTE: Comme mentionné au début de cette page, la variable async_load n'est valide que dans les événements asynchrones, ds_map c'est-à-dire que les points sont créés au début de l'événement, puis supprimés à la fin. Cependant, notez que le tampon temporaire dans lequel tous les fichiers audio sont stockés avec la carte sera également supprimé à la fin de l'événement. Vous devez donc le copier dans un tampon personnalisé si vous souhaitez le conserver pour une utilisation ultérieure.
Dans l'exemple d'utilisation ci-dessous, nous allons créer un tampon personnalisé pour stocker notre audio enregistré, et également définir notre jeu pour enregistrer à partir de la source d'entrée 0:channel_index = audio_start_recording(0);
audio_buffer = buffer_create(len, buffer_fast, 1);
Chaque étape du jeu maintenant que l'enregistrement est détecté déclenchera un événement d'enregistrement audio asynchrone où vous pourrez gérer quelque chose comme ceci:var channel = async_load[? "channel_index"];
if channel == channel_index
{
len = async_load[? "data_len"];
buffer_copy(async_load[? "buffer_id"], 0, len, audio_buffer, 0);
}
Ici, nous vérifions simplement la clé "channel_index" pour nous assurer qu'elle correspond à la valeur retournée lorsque nous avons commencé l'enregistrement, et si c'est le cas, nous copions le contenu du tampon temporaire créé pour cet événement dans notre tampon personnalisé. Après cela, vous pouvez faire ce que vous voulez avec le tampon personnalisé - vous pouvez le lire en utilisant les fonctions audio du tampon dédié, vous pouvez le traiter et l'envoyer sur le réseau, vous pouvez l'enregistrer sur le disque... Une fois votre audio enregistré dans un tampon, vous pouvez faire pratiquement tout ce que vous voulez.
L'événement Cloud est celui qui est déclenché par le rappel de l'un des cloud_ fonctions, comme cloud_synchronise. Il génère en fait un ds_map Ceci est exclusif à cet événement et est stocké dans la variable spéciale async_load (veuillez voir les fonctions individuelles pour les exemples de code qui expliquent l'utilisation de cet événement plus en détail). Cette structure ds_map a la structure suivante:La signification exacte de l'entrée de la carte "status" retournée est expliquée dans le tableau suivant:
- "status": Ceci contient le code d'état, où une valeur négative indique une erreur, dont une description sera contenue dans "errorString". Une valeur de 0 (ou une valeur positive) indique un succès (voir ci-dessous pour les valeurs exactes), et la chaîne "resultString" contiendra les données renvoyées ou un message de réussite.
- "id": L'identifiant qui a été renvoyé par la fonction appelée. Si vous déclenchez une série de cloud_ demandes, vous devez alors savoir à laquelle vous obtenez la réponse, et ainsi vous utiliseriez cette valeur pour comparer à la valeur que vous avez stockée lorsque vous avez envoyé la demande pour trouver la bonne.
- "description": La description du dernier fichier téléchargé.
- "resultString": Ceci contient une chaîne qui est le blob de données renvoyé du nuage.
- "errorString": renvoie une chaîne d'erreur pour toute erreur.
Valeur du statut errorString / resultString La description -1 errorString = "Non connecté à <SERVICE>" You have not successfully logged in to the given Cloud Service 0 resultString = données récupérées New game data downloaded from the cloud (following a cloud_synchronise call) 1 resultString = "AlreadySynchronized" No new data since you last called cloud_synchronise 2 resultString = "ConflictDeferral" A conflict was encountered, but the gamer chose to ignore it 3 resultString = "GameUploadSuccess" data from cloud_string_save or cloud_file_save was successfully uploaded to the cloud -n errorString = Description de l'erreur Any other negative number means a synchronisation failure
Comme les événements ci-dessus, l'événement Dialogues est uniquement déclenché lorsqu'il reçoit un rappel de l'une des fonctions utilisateur asynchrones spéciales, comme get_login_async() (Veuillez voir cette fonction pour un exemple de code étendu de la façon dont cet événement est utilisé). Ces événements sont ceux qui demandent un type d'entrée de l'utilisateur, qui peut être un nom, des informations de connexion, un numéro ou une couleur etc... Comme la plupart des appareils n'aiment pas être assis dans une boucle en attente d'une réponse, ils doivent être asynchrone et GameMaker Studio 2 continuera à fonctionner en arrière-plan pendant que ces fonctions ont un dialogue ouvert et jusqu'à ce qu'ils obtiennent l'entrée utilisateur requise qui déclenche cet événement.
Encore une fois, un ds_map est renvoyé avec l'ID contenu dans la variable spéciale async_load. Les valeurs contenues dans cette carte dépendent de la fonction utilisée, et vous devriez consulter les entrées individuelles pour chaque fonction dans ce manuel pour plus de détails.
L'événement HTTP est celui qui est déclenché par le rappel de l'un des http_ fonctions, comme http_post_string. Il génère en fait un ds_map (parfois appelé "dictionnaire") exclusif à cet événement et stocké dans la variable spéciale async_load (Veuillez voir les fonctions individuelles pour les exemples de code qui expliquent l'utilisation de cet événement plus en détail). Ce ds_map a la structure suivante:C'est pour quand vous utilisez le http_post_string() fonction, mais chacun des http_ Les fonctions peuvent renvoyer une carte légèrement différente, veuillez donc vous référer à l'entrée manuelle de chaque fonction pour connaître les données précises qui lui sont retournées.
- "id": L'identifiant qui a été renvoyé par la commande. Si vous déclenchez une série de http_ demandes, vous devez alors savoir à laquelle vous obtenez la réponse, et ainsi vous utiliseriez cette valeur pour comparer à la valeur que vous avez stockée lorsque vous avez envoyé la demande pour trouver la bonne.
- "status": Renvoie une valeur inférieure à 0 pour une erreur, 0 pour la réussite et 1 si le contenu est en cours de téléchargement.
- "result": Les données reçues (chaîne seulement), ou le chemin vers le fichier téléchargé si vous avez utilisé http_get_file().
- "url": L'URL complète que vous avez demandée.
- "http_status": le code d'état brut http (si disponible). Cela renvoie le code d'état Web standard pour la plupart des navigateurs, par exemple: 304 pour "Non modifié" ou 204 pour "Aucun contenu", etc...
NOTE: Comme async_load crée un ds_map, ces fonctions sont particulièrement utiles lorsqu'elles sont associées à json_encode et json_decode les fonctions.
Il pourrait également y avoir des données supplémentaires fournies par cette carte si vous avez demandé des fichiers à télécharger. Dans ce cas, le "status" aura une valeur de 1 et le ds_map contiendra ces clés supplémentaires:Notez que l'événement ne sera pas déclenché pour chaque paquet de données reçu, mais qu'il sera mis à jour à tout moment pendant le téléchargement dans la boucle de jeu principale. Notez également que cette fonctionnalité est actuellement disponible uniquement pour les plates- formes cibles Windows normales.
- "contentLength": C'est la taille du fichier que le serveur web a dit que vous devriez recevoir (peut-être -1 si le serveur ne retourne pas ces données).
- "sizeDownloaded": La taille des données qui ont déjà été téléchargées.
Cet événement peut uniquement être déclenché lorsque vous avez activé les achats In App pour votre jeu. Si vous avez ajouté cette fonctionnalité, l'événement sera déclenché dans les circonstances suivantes:L'événement créera toujours un spécial ds_map avec un ID d'index stocké dans la variable intégrée iap_data. Cette carte contiendra toujours la clé " type ", qui contiendra l'une des valeurs constantes suivantes:
- L'état du magasin change.
- Un produit (ou des produits) ont été activés.
- Le produit et les achats ont été restaurés.
- Un produit a été acheté.
- Un produit a été consommé.
Constant La description iap_ev_storeload Ceci est déclenché lorsqu'une modification est détectée dans le magasin de la plateforme cible. iap_ev_product Cet événement est déclenché lorsqu'un produit est activé et contiendra des informations supplémentaires sur le produit. iap_ev_restore Cet événement est uniquement déclenché lorsque vous utilisez le iap_restore_all fonction. iap_ev_purchase Lorsqu'un achat a été effectué, cet événement est déclenché. iap_ev_consume Lorsque vous utilisez la fonction iap_consume cela déclenche cet événement.
Chacun de ces "types" d'événements possibles ajoutera des clés supplémentaires à iap_data ds_map, qui peut ensuite être analysé pour obtenir les informations d'achat ou de produit nécessaires. Le contenu exact de iap_data Les cartes sont listées ci-dessous pour chaque événement "type".Lorsque vous activez vos achats, votre jeu tente de contacter le magasin cible, ce qui déclenche cet événement dans le processus. le iap_data map aura alors une clé additionnelle " status", qui aura l'une des constantes suivantes comme valeur:
Constant La description iap_storeload_ok Le magasin a été contacté et la connexion est bonne. iap_storeload_failed Il y a eu une erreur de connexion ou, pour une raison quelconque, le magasin n'est pas disponible.
Tous les achats activés déclencheront cet événement "type", mais seulement une fois par achat, donc si vous avez activé dix produits vous devriez vous attendre à ce que cet événement se déclenche dix fois. Si vous avez reçu cet événement, le iap_data ds_map contiendra la clé supplémentaire " index " qui contient la chaîne unique d' ID de produit pour le produit en cours d'activation. Vous pouvez ensuite utiliser la fonction iap_product_details avec ce produit ID pour obtenir plus d'informations.REMARQUE: Google Play ( Android ) ne peut demander des détails que pour les produits 20 à la fois, ce qui peut entraîner des temps de chargement assez longs pour les applications comportant un nombre important de produits.
Lorsque vous appelez la fonction iap_restore_all il déclenchera cet événement, en ajoutant une clé " result " au iap_data ds_map. Cette clé tiendra soit true ou false pour indiquer si les données d'achat ont été correctement restaurées à partir du magasin cible.
En demandant un achat en utilisant la fonction iap_acquire ce type d'événement sera déclenché. le iap_data ds_map aura la clé supplémentaire " index " qui contient la valeur unique d' identifiant d'achat pour le produit acheté. Vous pouvez ensuite utiliser la fonction iap_purchase_details avec cet ID d'achat pour obtenir plus d'informations.REMARQUE: Si le produit acheté est consommable, il doit être utilisé en utilisant iap_consume avant qu'un nouvel achat puisse être effectué.
Lors de l'utilisation de la fonction iap_consume ce type d'événement sera déclenché. le iap_data ds_map aura la clé additionnelle " product " qui contient la chaîne unique d' identifiant de produit pour le produit consommé.
Cet événement est déclenché lorsque vous chargez une image dans GameMaker Studio 2, à condition que vous ayez utilisé une URL ou un chemin d'accès valide avec la fonction de fichier de chargement applicable. Supposons par exemple que vous souhaitiez charger une image d'image-objet et que vous ne modifiiez l'image-objet en cours pour l'instance que lorsqu'elle est chargée. Eh bien, vous auriez quelque chose comme ça dans un événement de création ou un événement d'alarme (par exemple):spr = sprite_add("http://www.angusgames.com/game/background1.png", 0, false, false, 0, 0);
Cela va maintenant commencer à charger l'image dans l'appareil ou dans le navigateur, mais cela ne bloquera pas GameMaker Studio 2 pendant qu'il attend le chargement du fichier. Au lieu de cela, GameMaker Studio 2 continuera à fonctionner normalement jusqu'à ce que l'image soit chargée et le rappel déclenche l'événement Image Loaded, où un ds_map est créé et stocké dans la variable spéciale async_load. La carte contient les informations suivantes:
- "filename": Le chemin complet du fichier que vous avez demandé.
- "id": L'ID de la ressource que vous avez chargée. Ce sera la même chose que la variable à laquelle vous avez affecté la ressource.
- "status": Renvoie une valeur inférieure à 0 pour une erreur.
Vous devez ensuite affecter l'image nouvellement chargée à un arrière-plan dans cet événement. Ce qui précède est également vrai pour les sprites et les sons, avec un ds_map étant généré pour chacune de ces ressources comme indiqué ci-dessus, et l'exemple de code suivant montre comment les informations retournées seraient utilisées dans cet événement:
if ds_map_find_value(async_load, "id") == spr
{
if ds_map_find_value(async_load, "status") >= 0
{
sprite_index = spr
}
}Le code ci-dessus va d'abord vérifier l'identifiant de la carte ds_map qui a été créée, puis vérifier l'état du rappel. Si la valeur est supérieure ou égale à 0 (succès de la signalisation), le résultat du rappel sera utilisé pour définir l'index d'arrière-plan de l'image nouvellement chargée.
L'événement de mise en réseau est celui qui sera déclenché par tout trafic réseau entrant et est lié aux fonctions de réseau. Cet événement génère un fichier ds_map spécial exclusif à cet événement et stocké dans la variable spéciale async_load. Ce ds_map contiendra des informations différentes en fonction du type d'événement réseau qui l'a généré.Les clés suivantes sont communes à toutes les fonctions réseau reçues et seront toujours présentes dans le async_load carte:Les valeurs de retour possibles pour la clé "type" peuvent être l'une des trois constantes listées ci-dessous:
- "type": L'une des constantes répertoriées ci-dessous sera sa valeur de retour et désignera le type d'événement réseau.
- "id": l' identifiant du socket (un nombre réel, renvoyé par la fonction network_create_server ou network_create_socket ) qui reçoit l'événement. Dans la plupart des cas, l'ID de socket retournée est l'ID de TCP ou socket UDP qui a déclenché l'événement, si l'événement est déclenché dans un serveur et il est un événement de données (voir ci - dessous) puis l'ID de socket est celle du client qui a envoyé le Les données.
- "ip": L'adresse IP du socket (sous forme de chaîne).
- "port": Le port associé à l'adresse IP (utile pour travailler avec UDP).
Constant La description network_type_connect L'événement a été déclenché par une connexion. network_type_disconnect L'événement a été déclenché par une déconnexion. network_type_data L'événement a été déclenché par des données entrantes. network_type_non_blocking_connect L'événement a été déclenché par une connexion configurée comme non bloquante (vous pouvez utiliser la fonction network_set_config() pour ça).
Lorsque vous avez un événement du type network_type_connect, network_type_non_blocking_connect ou network_type_disconnect, la async_load La carte aura les clés supplémentaires suivantes:Il est à noter que l'événement de mise en réseau ne se déclenche pas dans les clients lorsque le serveur se déconnecte, et qu'aucun des network_type_* les événements seront déclenchés dans les clients lorsque le serveur auquel ils sont connectés se déconnecte, même si la connexion est basée sur TCP.
- "socket": Cette touche contiendra l'identifiant du socket de connexion / déconnexion.
- "réussi": Cette clé sera soit 0 ou 1, où 0 signifie que la connexion a expiré et 1 signifie qu'elle a réussi et que le socket est prêt à être utilisé.
Lorsque vous avez un network_type_data type événement, ce qui signifie que votre réseau a reçu des données, la carte créée aura les clés suivantes:
- "buffer": C'est l'unique "buffer id" qui est généré par l'événement. Un tampon de type "grow", octet aligné sur 1, est créé pour contenir l'identifiant qui doit être stocké dans une variable et utilisé pour tous les appels de fonction supplémentaires au tampon dans cet événement. Tout comme le async_load map, le tampon créé est automatiquement supprimé de la mémoire à la fin de cet événement. Pour plus d'informations sur les tampons, reportez-vous à la section Référence - Tampons
- "size": Il s'agit de la taille (en octets) des données du tampon en cours de réception.
Remarque: le tampon créé est uniquement valide dans ces événements et sera libéré lorsque l'événement est terminé.
L'événement de notification push est celui qui est déclenché par le rappel à partir des notifications push sur le système d'exploitation de l'appareil, soit à partir d'une source locale en utilisant la fonction push_local_notification, ou à partir d'une source distante (c'est-à-dire: votre serveur). Il génère un ds_map Ceci est exclusif à cet événement et est stocké dans la variable spéciale async_load (voir les fonctions individuelles qui déclenchent des événements asynchrones pour des exemples de code expliquant plus en détail l'utilisation de cet événement). Ce ds_map a les clés suivantes:Il peut y avoir des entrées de clé supplémentaires basées sur le "type" renvoyé et la valeur "status". Pour "status", si une erreur a été retournée ("0"), alors vous aurez aussi la clé suivante:
- "type": La valeur peut être "locale" pour une notification locale de périphérique, "distante" pour une notification à distance, ou "enregistrer" pour l'enregistrement de notification à distance.
- "status": La valeur sera "1" pour le succès ou "0" pour une erreur.
Si la valeur "status" est 1 (ie: pas d'erreur) alors le ds_map contiendra les valeurs supplémentaires suivantes, en fonction de la valeur de la clé "type":
- "error": Contient les détails de l'erreur reçue.
Pour mieux comprendre cela, nous avons créé un petit extrait d'exemple ci-dessous que vous pouvez consulter. Dans cet exemple, nous enverrons une notification push locale en utilisant le code suivant:
- "reg_id": Si le "type" reçu était "register", alors cette touche contiendra l'identifiant d'enregistrement de l'appareil pour les notifications à distance.
- "data": Si le "type" reçu était "local" ou "distant", alors cette clé contiendra la charge utile de la chaîne que vous avez définie lorsque vous avez appelé la fonction de notification.
var fireTime = date_inc_day(date_current_datetime(), 1);
var data = "daily_reward";
push_local_notification(fireTime, "Ahoy!", "Catch The Haggis Has A Present", data);
Ceci mettra un temporisateur pour "pousser" une notification à l'appareil quand un jour s'est écoulé. Quand le jour est terminé, si votre jeu est en arrière-plan ou non, une notification sera montrée à l'utilisateur avec le titre et le message donnés (sur iOS, le nom du jeu est affiché et le titre est ignoré), puis un événement de notification push asynchrone sera appelé. Notez que si le jeu est au premier plan lorsque l'heure de la notification arrive, il ne sera pas affiché, mais l'événement asynchrone sera toujours déclenché. Dans l'événement lui-même, vous gérer le rappel quelque chose comme ceci:var type = ds_map_find_value(async_load, "type");
var status = ds_map_find_value(async_load, "status");
if status == 0
{
//error of some kind
var error = ds_map_find_value(async_load, "error");
show_debug_message("error=" + string(error));
}
else
{
if type == "register"
{
global.reg_id = ds_map_find_value(async_load, "reg_id");
}
else
{
var data = ds_map_find_value(async_load, "data");
if data == "daily_reward"
{
global.Gold += 1000;
}
}
}
Cet événement sera déclenché par certaines fonctions liées au chargement et à l'enregistrement des tampons dans les fichiers, ainsi que lors du chargement ou du déchargement de l'audio de la mémoire. L'événement lui-même contiendra le construit dans async_load Carte DS qui sera remplie par les touches nécessaires à la fonction spécifique. Ceux-ci sont énumérés dans les sections ci-dessous.Lorsque vous utilisez les fonctions buffer_save_async() ou buffer_load_async() un événement asynchrone sera déclenché une fois le transfert de données terminé. Cet événement va peupler le async_load carte avec les paires clé / valeur suivantesCela vous permet d'interroger la progression de sauvegarde / chargement et d'afficher un message ou de changer de salle etc... lorsque le processus est terminé.
- "id": l'identifiant de la fonction asynchrone renvoyée par la fonction utilisée.
- "status": retournera true si les données ont été sauvegardées / chargées correctement, et false autrement.
Lorsque vous travaillez avec des groupes audio, vous pouvez les charger et les décharger de la mémoire en utilisant les fonctions audio_group_load() et audio_group_unload(). Lors de l'utilisation de la fonction de chargement, elle déclenchera cet événement lorsque l'ensemble des fichiers audio définis pour le groupe aura été chargé en mémoire et remplira la carte avec les paires clé / valeur suivantes:Lorsque tout l'audio a été chargé pour un groupe, cet événement se déclenchera et il pourra alors être utilisé pour changer de pièce, ou jouer une piste musicale etc...
- "type": cela nous indique le type d'événement appelé et sera " audiogroup_load "pour le chargement audio.
- "group_id": renvoie l'ID du groupe audio qui a été chargé (comme défini dans l' éditeur de groupe audio ).
Cet événement ne peut être déclenché que par les différentes fonctions sociales spécifiques et renvoie un ds_map stocké dans la variable async_load, contenant différentes paires clé / valeur en fonction du rappel de la fonction qui a déclenché l'événement.
Le fichier ds_map contiendra un certain nombre de clés, la plus importante étant la clé " id ". Cela retournera une constante qui peut ensuite être vérifiée dans le code pour déterminer lequel des nombreux rappels l'événement a reçu. Une fois que vous avez analysé cette clé et comparé la valeur renvoyée avec les constantes disponibles, vous pouvez continuer à extraire le reste des informations de la carte.Les pages de fonctions sur le jeu social - Réalisations et classements dans la section Référence détaillent les fonctions et les rappels ainsi que les constantes utilisées pour déclencher cet événement, mais il existe également certaines circonstances dans lesquelles il sera déclenché sans un appel de fonction du jeu est en cours d'exécution:
- lorsque votre jeu est lancé à partir du tableau de bord du système d'exploitation
- lorsque vous remplissez un défi
- quand un autre joueur termine un défi
- lorsque le jeu est démarré à partir du tableau de bord du système d'exploitation en sélectionnant un défi
L'un des rappels ci-dessus déclenchera l' événement social et un async_load map sera généré avec les détails suivants (notez qu'il existe une valeur de clé "id" différente pour définir chacune des différentes raisons pour lesquelles l'événement a été appelé, mais tous les autres contenus de la carte sont les mêmes):
Vous trouverez ci-dessous un petit extrait de code comme exemple d'utilisation:
- " id " - La valeur de cette clé dépend du type de rappel qui déclenche l'événement. cela peut être l'une de ces constantes:
- achievement_challenge_received - Un défi a été reçu
- achievement_challenge_completed - Un défi a été complété.
- achievement_challenge_completed_by_remote - Un défi a été complété par l'autre joueur.
- achievement_challenge_launched - Le jeu a été lancé à partir du tableau de bord du système d'exploitation avec le défi donné.
- " playerid " - L'identifiant du joueur pour le challenge.
- " issuerid " - L'identifiant de la personne qui a lancé le défi.
- " state " - L'état du challenge, qui aura une valeur de 0 - 3 (comme une chaîne de caractères) pour invalide, en attente, complété ou refusé.
- " message " - Le message texte pour le défi.
- " date d'émission " - Date d'émission du challenge
- " completeddate " - La date d'achèvement du challenge.
- " type " - Le type de défi donné. Peut être l'une des deux constantes:
- achievement_type_score_challenge - Un défi basé sur la valeur du score.
- achievement_type_achievement_challenge - Un défi basé sur un exploit.
- " identificateur " - La chaîne d'identification pour le défi.
- " score " - Le score lié au défi.
var ident = ds_map_find_value(async_load, "id" );
if ident == achievement_challenge_completed;
{
player_id = ds_map_find_value(async_load, "playerid");
issuer_id = ds_map_find_value(async_load, "issuerid");
state = ds_map_find_value(async_load, "state");
date_completed = ds_map_find_value(async_load, "completeddate");
date_issued = ds_map_find_value(async_load, "issueddate");
ach_type = ds_map_find_value(async_load, "type");
ach_ident = ds_map_find_value(async_load, "identifier");
ach_score = ds_map_find_value(async_load, "score");
}
Certaines fonctions Facebook vont déclencher un événement social asynchrone et créer un ds_map avec quelques informations spécifiques. Les informations renvoyées dépendront du "type" d'événement qui a été appelé. Vous pouvez vérifier cela en lisant la clé "type" de la carte ds_map, qui sera la chaîne suivante pour un événement Facebook:
- " facebook_permission_request "
Lorsque l'événement est déclenché et est de ce type, il y aura également des clés supplémentaires qui peuvent être vérifiées:
- " requestId " - La valeur d'ID de la requête renvoyée par le facebook_request_xxx_permission() fonction qui a déclenché l'événement
- " result " - Ce sera l'une des chaînes suivantes:
- " accordé " - les autorisations ont été acceptées par l'utilisateur
- " denied " - une ou plusieurs autorisations n'ont pas été acceptées par l'utilisateur
- " erreur " - une erreur est survenue
- « erreur » - Il contiendra une description de l'erreur, mais il est présent que lorsque « résultat » = « erreur ».
Cet événement ne peut être déclenché que par les fonctions de l' API Steam et renvoie un ds_map stocké dans la variable async_load, contenant différentes paires clé / valeur en fonction du rappel de la fonction qui a déclenché l'événement. La carte contiendra toujours la clé " event_type " qui peut ensuite être analysée pour trouver le type de fonction qui a déclenché l'événement et changer le code requis.
Lorsque vous appelez une fonction qui déclenche cet événement, elle génère une valeur d'identifiant asynchrone unique qui doit être stockée dans une variable et vérifiée, comme async_load map contiendra toujours une clé d'identification que vous pourrez ensuite analyser et vérifier que vous répondez à l'événement correct. En fait, la carte contiendra toujours les clés suivantes, quelle que soit la fonction Steam utilisée pour générer la réponse asynchrone:
- " id " - L'identifiant asynchrone renvoyé par la fonction qui a déclenché l'événement
- " résultat " - Le résultat de l'opération (une valeur réelle). Ce sera soit la constante GML ugc_result_success ou un autre nombre réel. Vous devriez donc vérifier cette constante pour vous assurer que l'appel a réussi et, dans le cas contraire, que quelque chose ne fonctionne pas correctement. Le reste des valeurs possibles renvoyées sont affichées comme le résultat de la valeur Steam "EResult" et vous devriez voir steamclientpublic.h dans les en-têtes SDK pour toutes les 89 valeurs possibles.
- " event_type " - Une chaîne indiquant le type d'événement (voir ci-dessous pour les détails)
Lorsque vous utilisez les fonctions Steam pour télécharger un leaderboard (soit steam_upload_score() ou steam_upload_score_buffer() ) le retour ds_map aura les paires clé / valeur suivantes:Vous pouvez voir des exemples de cela sur les pages pour les fonctions de téléchargement de score.
- " event_type " - Cette clé contiendra la valeur " leaderboard_upload "
- " post_id " - Cette clé doit correspondre à la valeur d'ID renvoyée par la fonction d'appel de téléchargement
- " lb_name " - Cette clé contient le nom du leaderboard qui a été posté sur
- " succès " - Sera 1 si le poste a réussi, 0 a échoué
- " updated " - Sera 1 si le score du classement a été réellement mis à jour (ie: le nouveau score était meilleur) ou 0 sinon
- " score " - Cette clé contient le score qui a été posté
Lorsque vous utilisez les fonctions Steam pour télécharger un classement ( steam_download_scores(), steam_download_scores_around_user() ou steam_download_friends_scores() ) le retour ds_map aura les paires clé / valeur suivantes:Nous montrerons un exemple du fonctionnement du téléchargement des données de score en demandant le classement des dix premiers pour le classement donné et en analysant ses résultats dans l' événement Steam Async (pour télécharger des exemples, veuillez consulter les pages de fonctions appropriées). Pour commencer, nous devons demander les scores avec le code suivant:
- " event_type " - Cette clé contiendra la valeur " leaderboard_download "
- " id " - Cette clé doit correspondre à la valeur d'ID renvoyée par la fonction d'appel de téléchargement
- " status " - L'état du callback, où -1 correspond à un échec ou qu'aucun résultat n'a été retourné, et 0 est un succès.
- " lb_name " - Cette clé contient le nom du leaderboard qui a été posté sur
- " numEntries " - Nombre de "rangées" de données de classement en cours de renvoi.
- " entries " - Une chaîne d'objet JSON qui contient un autre ds_map, qui contiendra la clé "default" (signifiant qu'aucun résultat n'est contenu dedans) ou la clé "entries", dont vous pouvez alors obtenir la valeur. cette valeur retournée pour "entrées" sera un ds_list contenant chacun des rangs du classement, où chaque entrée de la liste fera elle-même référence à une autre ds_map qui contiendra les clés "name", "score" et "rank", et il peut également contenir une clé "data" en fonction de la fonction utilisée pour le téléchargement.
score_get = steam_download_scores("Game Scores", 1, 10);
Cela enverra une requête au serveur Steam pour les scores du classement "Game Scores", en stockant l' identifiant asynchrone de la requête dans la variable "score_get". Cela sera ensuite traité dans l' événement Steam Async de la façon suivante:var async_id = ds_map_find_value(async_load, "id");
if async_id == score_get
{
var entries = ds_map_find_value(async_load, "entries");
var map = json_decode(entries);
if ds_map_exists(map, "default")
{
ds_map_destroy(map);
exit;
}
else
{
var list = ds_map_find_value(map, "entries");
var len = ds_list_size(list);
var entry;
for(var i = 0; i < len; i++;)
{
entry = ds_list_find_value(list, i );
steam_name[i] = ds_map_find_value(entry, "name");
steam_score[i] = ds_map_find_value(entry, "score");
steam_rank[i] = ds_map_find_value(entry, "rank");
if (ds_map_exists(entry, "data"))
{
var data = ds_map_find_value(entry, "data");
var buffId = buffer_base64_decode(data);
var message = buffer_read(buffId, buffer_string);
show_debug_message( " -- attached message: " + string(message));
buffer_delete(buffId);
}
ds_map_destroy(entry);
}
ds_list_destroy(list)
}
ds_map_destroy(map)
}
Ce que nous faisons ici est d'abord vérifier la clé "id" de la spéciale async_load carte. Si cette valeur est la même que la valeur de la fonction de rappel d'origine (stockée dans la variable "score_get"), nous continuons à traiter les données. La première chose que nous faisons est d'analyser async_load ds_map pour la clé "entrées" qui contiendra un objet JSON contenant les données du leaderboard. Cet objet JSON est ensuite décodé (voir json_decode ) comme un autre ds_map, et ce nouvel identifiant de carte est stocké dans la variable "map".
Cette carte est vérifiée pour la clé "par défaut" et si cela est trouvé alors la carte est détruite et l'événement est quitté. Si aucune clé "default" n'est trouvée, le code analysera la carte pour extraire les informations nécessaires sur le leaderboard, en extrayant d'abord une liste ds_list de la clé "entries" de la carte ds_map, puis en passant en boucle chaque entrée de la liste obtenir un autre ds_map avec le nom, le score et le rang de chaque entrée. Ces valeurs sont ensuite stockées dans des tableaux, puis nous vérifions s'il existe une clé "data" supplémentaire. S'il y a (c'est-à-dire: le score a été téléchargé avec un paquet de données supplémentaire), nous l'analysons et l'envoyons à la console du compilateur pour le déboguer, avant de détruire le tampon, puis de détruire la carte. Notez que si la clé "data" est incluse, elle doit être décodée en utilisant buffer_base64_decode() avant qu'il puisse être lu correctement.
Une fois la boucle terminée, la liste des entrées est détruite, de même que la carte dont elle provient. Il n'y a pas besoin de détruire le async_load ds_map car ceci est géré pour vous par GameMaker Studio 2.
Lorsque vous utilisez les fonctions Steam pour télécharger du contenu généré par l'utilisateur (UGC), un certain nombre d'entre eux déclencheront cet événement. Cependant, chaque fonction génère un async_load ds_map avec des paires clé / valeur différentes (bien qu'elles contiennent toujours les clés générales " id ", " result " et " event_type "), veuillez donc voir la page spécifique à la fonction utilisée pour les détails et les exemples.
L'événement Steam Async peut également être déclenché lorsqu'un utilisateur s'abonne à un élément en dehors du jeu. Par exemple, il tabule vers un navigateur et s'abonne à un nouvel élément, puis revient au jeu. Dans ces cas, le async_load map ne contiendra que les informations suivantes (et aucune des valeurs par défaut répertoriées en haut de cette page):L'événement Steam Async peut également être déclenché lorsqu'un abonnement à un atelier est souscrit, soit depuis l'application, soit en externe depuis un navigateur d'atelier. async_load map contiendra les paires clé / valeur suivantes:
- " event_type " - Cette clé contiendra la valeur " ugc_item_installed "
- " published_file_id " - l'ID de l'élément UGC nouvellement installé (vous pouvez utiliser la fonction steam_ugc_get_item_install_info() pour obtenir le chemin vers l'élément installé)
L'événement sera déclenché si un élément est également désabonné, la carte DS contenant ce qui suit:
- " event_type " - Cette clé contiendra la valeur " ugc_item_subscribed" "
- " published_file_id ": cette clé a l'ID de fichier publié de l'élément nouvellement abonné
- " event_type " - Cette clé contiendra la valeur " ugc_item_unsubscribed" "
- " published_file_id ": Cette clé a l'ID de fichier publié de l'élément non abonné
Cet événement peut uniquement être déclenché par un événement de niveau système (tel que la détection d'une manette de jeu ou la connexion automatique à XBox Live). ds_map stocké dans la variable async_load, contenant différentes paires clé / valeur en fonction de l'événement de niveau système ayant déclenché le rappel.
Lorsque cet événement est déclenché pour une manette connectée ou déconnectée, l'une des paires clé / valeur suivantes est renvoyée async_load carte:
- " event_type " - le type d'événement système reçu, qui sera l'une des chaînes suivantes:
- " gamepad discover " - se produit lorsque le système signale qu'une nouvelle manette a été connectée
- " gamepad lost " - se produit lorsque le système a perdu la connexion à une manette
- " pad_index " - l'index du pad qui a été ajouté ou supprimé
Cet événement vous permet désormais de déplacer toute la logique de vérification de la manette de jeu depuis l'événement d'étape ou un événement d'alarme dans l'événement système et de l'exécuter uniquement lorsqu'elle est réellement requise.
L'événement système asynchrone peut être déclenché lors du ciblage de la XBox One à l'aide de l'exportation UWP et en cochant l'option Activer XBox Live dans les options de jeu UWP. Lorsque vous démarrez le projet UWP de GameMaker Studio 2 sur lequel Xbox Live est activé, le projet tente automatiquement de se connecter en mode silencieux à Xbox Live. Les résultats de cette tentative de connexion seront renvoyés comme l'une des paires clé / valeur suivantes async_load carte:
- " event_type " - le type d'événement système reçu, qui sera l'une des chaînes suivantes:
- " utilisateur connecté " - la connexion de l'utilisateur silencieux a été effectuée avec succès
- "La connexion de l'utilisateur a échoué " - la connexion de l'utilisateur en mode silencieux a échoué (lorsque cela se produit, vous pouvez utiliser la fonction xboxlive_show_account_picker() pour que l'utilisateur choisisse un compte avec lequel se connecter)
- " utilisateur déconnecté " - l'utilisateur s'est déconnecté
Pour plus d'informations sur les fonctions spécifiques disponibles pour XBox Live, veuillez voir ici.