Memento AOZ

Estimated reading time:14 minutes 22 seconds

Memento AOZ

Voici une liste des différents codes source et syntaxes courante utilisées dans le langage AOZ (anciennement AMOS BASIC).
Ce fichier est un canevas qui s'étoffera au fur et à mesure de mes expérimentations sur ce langage et son éco système .

Références/Sources:

Syntaxe de Base

For n = 1 to 20
  Pen n
  Locate 40,n
  Print name$ + " is great!"
  Wait 0.5
Next

Exemple d'application commentée

  ////////////////////////////////
  // Configuration du programme //
  ////////////////////////////////

  #splashScreen:False// Essayez de le régler sur "True" pour voir l'effet
  #googleFont:"acme"// Sélectionnez la police graphique à utiliser. Voir note plus loin.
  Curs Off // Le curseur à l'écran n'est pas nécessaire

  /////////////////////////////////////////
  // Configuration de segments de chaîne //
  /////////////////////////////////////////

  ST9$="Que dois-je déplacer ? "
  ST10$="(H)omme "
  ST11$="(R)enard "
  ST12$="(P)oulet "
  ST13$="(S)ac de maïs "
  All$=ST9$+ST10$+ST11$+ST12$+ST13$'Remarquez comment les chaînes peuvent être ajoutées ensemble (on dit "concaténées")
  //Lorsque All$ est affiché, il ressemble à ceci: "Que-dois je déplacer ? (H)omme (R)enard (P)oulet (S)ac de maïs ".
  //Pendant le jeu, différentes chaînes partielles seront concaténées pour montrer les différents choix disponibles pour le joueur.
  //REMARQUE: N'oubliez pas d'ajouter un espace à la fin d'un segment de chaîne pour formater correctement la chaîne terminée

  ////////////
  // Global //
  ////////////

  //Comme vu précédemment, le mot "Global" permet à ces variables d'être accessibles dans toutes les parties du programme.
  Global All$,ST9$,ST10$,ST11$,ST12$,ST13$

  ////////////////////////
  // Variable booléenne //
  ////////////////////////

  Global STOPME

  // STOPME est utilisé comme variable booléenne. Les valeurs booléennes sont comme un interrupteur d'éclairage,
  // Elles ne peuvent être que dans l'un des deux états, par exemple. 'True/False', ou '0/1', ou 'On/Off'
  // Nous allons utiliser cette variable booléenne pour arrêter le programme.
  // Consultez la note qui suit STOPME dans la boucle de programme principale.

  ////////////////////////////////
  // Polices de texte graphique //
  ////////////////////////////////

  // Ici, nous introduisons les polices de texte graphique:
  // Dans les leçons précédentes, nous avons utilisé les polices de texte par défaut pour afficher du texte à l'écran.
  // Celles-ci sont à nouveau utilisées dans ce jeu pour afficher des messages en haut de l'écran.
  // Cependant, cette fois, pour l'écran d'introduction et les textes messages pour le joueur, nous avons utilisé
  // une police de texte graphique Google, visuellement plus intéressante, appelée "Acme"

  // Les polices graphiques peuvent être positionnées n'importe où sur l'écran en utilisant des coordonnées graphiques en pixels
  // plutôt que des colonnes et des lignes de texte. Par exemple: Text 40,170

  // Une couleur de police graphique est définie avec "Ink". Par exemple: Ink 1

  // Définir la police indique au programme quelle police utiliser et avec quelle taille. Par exemple: Set Font "acme",55
  // Bien sur, des variables chaînes peuvent être utilisées à la place d'un texte entre guillemets. Par exemple: Text 40,170, ST9$
  // Comme le message de titre n'est utilisé qu'une fois au début du programme que nous avons utilisé un texte entre guillemets,
  // Ex: Text 40,170, "Un homme doit faire traverser une rivière avec trois choses"

  CLS 11 // Efface l'écran avec la couleur 11 (vert)

  //Définit la couleur d'encre, le nom et la taille de la police
  Ink 1: Set Font "acme",55

  //Remarquez comment le texte est positionné en utilisant les coordonnées graphiques en pixels (et non en colonne et en ligne de texte)
  Text 40,170,"Un homme doit traverser une rivière avec trois choses:"
  Text 270,300,"Un renard, un poulet et un sac de maïs"
  Text 270,430,"Il ne peut prendre qu'une chose à la fois"

  // Remarquez le changement de couleur et de taille de police sur la même ligne
  Ink 0:Set Font "acme",40 // Diminue la taille de la police
  Text 500,550,"Pensez à activer le son"

  Ink 5 // Change la couleur de la police

  Text 280,630,"Appuyez sur n'importe quelle touche pour continuer"

  Ink 5:Set Font "acme",20 // Diminue encore la taille de la police

  Text 500,690,"AOZ Studio - Leçon 6 - Neil Ives - Fev 2020"

  Wait Key // Evident non ?

  ////////////////////////////
  // Configurer l'écran de jeu //
  ////////////////////////////

  CLS 11 // Efface l'écran (en vert)
  Ink 20:Bar 500,0 To 800,1080 // Dessine la rivière en utilisant la couleur d'encre bleue et l'instruction Bar x1,y1 to x2,y2
  Ink 10: Bar 0,0 to 1300,90 // Crée une zone de message pleine largeur en haut de l'écran
  Locate ,1:Paper 10:Pen 1:Centre All$ // Utilise des polices de texte simples (pas les polices graphiques)
  //Voir ci-dessus comment All$ a été composé avec des chaînes plus courtes.

  /////////////
  // Sprites //
  /////////////

  // Les sprites sont des objets graphiques qui peuvent être déplacés à l'écran et
  // dont on peut changer l'image.
  // Par exemple, dans ce jeu, le renard, le poulet et le bateau utilisent
  // une image inversée quand ils passent de l'autre côté de la rivière.
  // Aussi, gardez un oeil sur les autres changements d'image!

  // Placer les Sprites dans les positions de départ en utilisant des coordonnées graphiques.
  // Le premier Sprite est l'image d'un petit bateau
  Sprite 1,330,560,6 // Bateau

  // Les chiffres qui suivent le mot Sprite sont:
  //le numéro du Sprite (nombre), la position horizontale, la position verticale, le numéro de l'image à afficher.
  // Dans ce jeu, les images sont au format .png, numérotées de 1 à 16.
  // Le dossier "images" qui contient les images se trouve dans le dossier 'ressources' situé dans celui de l'application,

  // Maintenant, le reste des Sprites   .
  Sprite 2,0,365,10// Homme
  Sprite 3,400,490,5 // Sac de Maïs
  Sprite 4,170,430,4 // Renard
  Sprite 5,290,470,2 // Poulet

  ///////////////////////
  // La logique du jeu //
  ///////////////////////

  // Dans la version précédente de ce jeu (leçon 3) nous avons utilisé les positions horizontales de
  // chaînes affichées pour décider si un mauvais coup avait été joué, ou si le joueur avait gagné.
  // Ce programme utilise les positions horizontales des Sprites pour faire la même chose.

  ////////////////////////////
  // Intruction While/ Wend //
  ////////////////////////////

  // Ce programme comporte une boucle While/Wend à l'intérieur de la boucle Do/Loop principale.
  // En résumé:
  // While Choice$=""
  //   Choice$=Inkey$
  // Wend
  // La boucle ci-dessus signifie:
  //Tant que Choice$="" ("" signifie une chaîne vide), continue à boucler jusqu'à la "fin de la boucle While" (le mot raccourci est "Wend")

  ///////////////////////
  // Intruction Inkey$ //
  ///////////////////////

  // Inkey$ lit les caractères saisis au clavier
  // Lorsque Inkey$ obtient une valeur du clavier, elle est transmise à la variable chaîne Choice$,
  // et comme Choice$ a maintenant une valeur (il est différent d'une chaine vide)
  // le programme sort de la boucle While/Wend.

  // Contrairement à "Input", la combinaison While/Wend et Inkey$ ne nécessite pas d'appuyer sur la touche 'Entrée' après avoir fait un
  // le choix. Cela permet donc une réponse plus immédiate pour le joueur.

  ////////////////////////////////////
  // Boucle principale du programme //
  ////////////////////////////////////

  Do
    If STOPME=TRUE then Goto MARK // Nécessaire pour éviter l'attente d'une touche (boucle ci-dessous) quand le programme doit se terminer.

    While Choice$="" // Il s'agit d'une autre forme de boucle, en attente de l'appui d'une touche sur le clavier
      Choice$=Inkey$
    Wend

    // Envoyer la valeur sélectionnée par l'utilisateur à la procédure PLACE_SPRITES
    PLACE_SPRITES[Choice$]

    Choice$="" // Vider la variable chaîne "Choice$" afin qu'elle soit prête pour la prochaine boucle While/Wend

    MARK:
  loop

  ///////////////////////////////
  // Rappel sur les procédures //
  ///////////////////////////////

  // Dans une leçon précédente, vous avez vu comment les procédures peuvent être utilisées comme blocs de construction modulaires,
  // chacune contenant son propre code informatique.
  // Dans ce jeu, il existe trois procédures: PLACE_SPRITES, CHECK_IT et END_MESSAGES

  // Voici une description de chaque procédure:

  /////////////////////////////
  // Procédure PLACE_SPRITES //
  /////////////////////////////

  // Prend l'entrée des utilisateurs (à partir de Inkey$ dans la boucle principale) et la convertit en majuscules,
  // (car nous ne pouvons pas savoir si l'utilisateur a entré des majuscules ou des minuscules).
  // La procédure utilise une structure 'If/Else/End If' pour vérifier d'abord si Sprite2, (celui avec l'image de l'homme) se trouve du coté gauche
  // (position 0).
  // Le programme déplace ensuite l'un des éléments sélectionnés par les lettres "H", "R", "P", "M" à travers la rivière.
  // Si l'homme n'est pas sur la gauche, il doit être sur le côté droit de la rivière pour que la déclaration "Else" capture la position alternative.
  // (Le Sprite avec l'image du bateau bouge toujours avec l'homme.)

  // La position du texte dans chaque section est stockées dans TX afin que le message pour le joueur s'affiche correctement quand il sélectionne
  // une lettre: avec "C,"R" etc  ., il voit le texte Poulet", "Renard" etc  .
  // Avant que le message ne s'affiche, cette zone d'écran est effacée à l'aide de l'instruction "Cls" et en utilisant la couleur d'arrière-plan (Paper).
  // Enfin, la procédure CHECK_IT est appelée.

  ////////////////////////
  // Procédure CHECK_IT //
  ////////////////////////

  // Cette procédure fait deux choses; elle modifie les textes de sélection en haut de l'écran,
  // (voir la note précédente sur la configuration des fragments de texte)

  // Cela signifie que l'utilisateur ne voit que les sélections pertinentes. Par ex., si le Renard n'est pas du même côté que l'homme, il ne peut pas le sélectionner.
  // Puis CHECK_IT recherche les situations qui signifient que le jeu est terminé.

  // Il se peut que le joueur ait placés tous les objets de l'autre côté de la rivière et qu'il ait gagné le jeu,
  // ou bien cela peut signifier que le renard a mangé le poulet, etc  .
  // A la fin de cette Procédure, END_MESSAGES reçoit une valeur numérique.

  //////////////////////////////
  // Procédure END_MESSAGES //
  //////////////////////////////

  // Cette procédure traite la sélection et le formatage d'un des six messages pouvant être affichés à la fin du jeu.
  // Cette procédure ajoute un peu d'ambiance grace à des sons et des changements d'image.

  /////////////////////////
  // intruction Sam Play //
  /////////////////////////
  // Sam Play est utilisé dans Proc END_MESSAGES.
  // Sam Play joue simplement un échantillon sonore (un "sample").
  // Les sons utilisés dans ce jeu sont des fichiers .wav, nommés '1.wav', '2.wav' et '3.wav'
  // Le dossier "samples" qui contient les sons se trouve dans le dossier 'ressources' situé dans celui de l'application,

  // Etudier les messages de fin pour découvrir comment les sons et les périodes d'attente sont utilisés pour un créer un effet plus intéressant.

  Procedure PLACE_SPRITES[C$]
    // Place les Sprites à l'emplacement prédéfini, en fonction de l'entrée utilisateur. Seuls les caractères autorisés (H, R, P, M) seront traités

    C$ = Upper$(C$) // Entrée mis en majuscule, comme précédemment

    // Homme placé à gauche
    If X Sprite (2)=0 // le Sprite 2 est l'Homme
      If C$="H"
        Sprite 1,770,560,7 // Bateau (bouge toujours avec Homme)
        Sprite 2,1110,365,10 // Homme
      End if

      If C$="R"
        Sprite 1,770,560,7 // Bateau
        Sprite 2,1110,365,10 // Homme
        Sprite 4,990,430,1 // Renard
      End If

      If C$="P"
        Sprite 1,770,560,7 // Bateau
        Sprite 2,1110,365,10 // Homme
        Sprite 5,900,470,3 // Poulet
      End If

      If C$="M"
        Sprite 1,770,560,7 // Bateau
        Sprite 2,1110,365,10 // Homme
        Sprite 3,800,490,5 // Sac de maïs
      End If
      TX=900 // Position du message pour le joueur (voir plus bas)

    Else // Homme pas à gauche, donc on utilise la partie "Else"
      If C$="H"
        Sprite 1,330,560,6 // Bateau (bouge toujours avec Homme)
        Sprite 2,0,365,10 // Homme
      End if

      If C$="R"
        Sprite 1,330,560,6 // Bateau
        Sprite 2,0,365,10 // Homme
        Sprite 4,170,430,4 // Renard
      End If

      If C$="P"
        Sprite 1,330,560,6 // Bateau
        Sprite 2,0,365,10 // Homme
        Sprite 5,290,470,2 // Poulet
      End If

      If C$="M"
        Sprite 1,330,560,6 // Bateau
        Sprite 2,0,365,10 // Homme
        Sprite 3,400,490,5 // Sac de maïs
      End If
      TX=220 // Position du message pour le joueur (voir plus bas)
    End If

    // Afficher le texte des commentaires aux positions définies par TX
    Cls 11,200,100 to 500,170 // Effacer le texte précédent sur le côté gauche
    Cls 11,880,100 to 1180,170 // Effacer le texte précédent sur le côté droit
    Ink 1:Set Font "acme",40
    If C$="P" then Text TX,150,"Poulet"
    If C$="R" then Text TX,150,"Renard"
    If C$="M" then Text TX,150,"Sac de maïs"
    If C$="H" then Text TX,150,"Homme"

    CHECK_IT // Aller à la procédure qui vérifie les mauvaises décisions

  End proc

  Procedure CHECK_IT

    //------------- Mettre à jour les choix dans la barre supérieure -------------

    Ink 10: Bar 0,0 to 1300,90 // Effacer le message précédent

    Locate 0,1:Paper 10:Pen 1 // Configurer les couleurs d'affichage

    // Utilise les positions horizontales de Sprite, dérivées de "X Sprite ()" pour ajouter
    // les chaînes à utiliser: ST10$+ST11$+ST12$+ST13$ etc  .
    // Il s'agit de tous les choix possibles qui ne déclenchent pas le message "Fin de partie"Tout le monde est à gauche
    If X Sprite(2) = 0 and X Sprite(3) = 400 and X Sprite(4) = 170 and X Sprite(5) = 290Then Centre ST10$+ST11$+ST12$+ST13$

    // Homme, Renard, Maïs sur le coté gauche
    If X Sprite(2) = 0 and X Sprite(3) = 400 and X Sprite(4) = 170and X Sprite(5) = 900 then Centre ST10$+ST11$+ST13$

    // Homme, Renard, Chicken sur le coté gauche
    If X Sprite(2) = 0 and X Sprite(3) = 800 and X Sprite(4) = 170 and X Sprite(5) = 290 then Centre ST10$+ST11$+ST12$

    // Homme, Poulet, Maïs sur le coté gauche
    If X Sprite(2) = 0 and X Sprite(3) = 400 and X Sprite(4) = 990 and X Sprite(5) = 290 then Centre ST10$+ST12$+ST13$

    // Homme, Poulet sur le coté gauche
    If X Sprite(2) = 0 and X Sprite(3) = 800 and X Sprite(4) = 990 and X Sprite(5) = 290 ThenCentre ST10$+ST12$

    // Homme, Renard, Maïs sur le coté droit
    If X Sprite(2) = 1110 and X Sprite(3) = 800 and X Sprite(4) = 990 and X Sprite(5) = 290 then Centre ST10$+ST11$+ST13$

    // Homme, Renard, Poulet sur le coté droit
    If X Sprite(2) = 1110 and X Sprite(3) = 400 and X Sprite(4) = 990 and X Sprite(5) = 900 then Centre ST10$+ST11$+ST12$

    // Homme, Poulet, Maïs sur le coté droit
    If X Sprite(2) = 1110 and X Sprite(3) = 800 and X Sprite(4) = 170 and X Sprite(5) = 990 ThenCentre ST10$+ST12$+ST13$

    // Homme, Poulet sur le coté droit
    If X Sprite(2) = 1110 and X Sprite(3) = 400 and X Sprite(4) = 170 and X Sprite(5) = 900 ThenCentre ST10$+ST12$

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    // Vérifier la "fin de partie" en utilisant les positions horizontales de Sprite, dérivées de "X Sprite ()"
    // Envoyer un numéro de message à Proc END_MESSAGES

    // Renard, Poulet, Maïs sont seuls sur le côté gauche
    If X Sprite(4) = 170 and X Sprite(5) = 290 and X Sprite(3) = 400 and x Sprite(2) = 1110Then END_MESSAGES[1]

    // Renard, Poulet sont seuls sur le côté gauche
    If X Sprite(4) = 170 and X Sprite(5) = 290 and X Sprite(2) = 1110 then END_MESSAGES[2]

    // Poulet, Maïs sont seuls sur le côté gauche
    If X Sprite(5) = 290 and X Sprite(3) = 400 and X Sprite(2) = 1110 ThenEND_MESSAGES[3]:

    // Renard, Poulet sont seuls sur le côté droit
    If X Sprite(4) = 990 and X Sprite(5) = 900 and X Sprite(2) = 0 then END_MESSAGES[4]

    // Poulet, Maïs sont seuls sur le côté droit
    If X Sprite(5)=900 and X Sprite(3) = 800 and X Sprite(2) = 0 Then: END_MESSAGES[5]

    // Renard, Poulet, Maïs, Homme sont tous sur le côté droit (C'est gagné !)
    If X Sprite(4) = 990 and X Sprite(5) = 900 and X Sprite(3) = 800 and X Sprite(2)= 1110Then END_MESSAGES[6]

  End Proc

  Procedure END_MESSAGES[MESSAGE]
    //Afficher les messages de fin de partie appropriés

    If MESSAGE = 1
      Ink 10: Bar 0,0 to 1300,90
      Sam Play 2 // Lit le son associé au poulet
      Locate ,1:Paper 10:Pen 1:Centre "Le poulet a mangé le maïs  ."
      Wait 0.5 // Pause d'une demi-seconde pour un effet dramatique!
      'Sprite Off 3 // Supprimer le maïs [Sprite off ne fonctionne pas dans cette version bêta d'AOZ]
        Sprite 3,-100,490,5 // A la place, met le maïs en dehors de l'écran visible
      Sprite 5,,,13 // L'image change pour un gros poulet
      Wait 2 // Pause de 2 secondes pour un effet dramatique!
      'Sprite Off 5 // Supprimer le Poulet [Sprite off ne fonctionne pas dans cette version bêta d'AOZ]
        Sprite 5,-100,470,2 // A la place, met le Poulet en dehors de l'écran visible
      Sprite 4,,,16 // L'image change pour un gros Renard
      Wait 0.5 // encore une Pause
      Sam Play 3 // Lit le son associé au Rot
      Bar 0,0 to 1300,90:Locate ,1:Centre "  .puis le renard a mangé le poulet!":Wait 3
    End if

    If MESSAGE = 2 Then Sam Play 3: Sprite 5,-100,470,2:Sprite 4,,,16:Ink 10: Bar 0,0 to 1300,90:Locate ,1:Paper 10:Pen 1:Centre "Le renard a mangé le poulet !":Wait 2
    If MESSAGE = 3 Then Sam Play 2: Sprite 3,-100,490,5:Sprite 5,,,13:Ink 10: Bar 0,0 to 1300,90:Locate ,1:Paper 10:Pen 1:Centre "Le poulet a mangé le maïs !":Sam Play 2: Wait 2
    If MESSAGE = 4 Then Sam Play 3: Sprite 5,-100,470,2:Sprite 4,,,15:Ink 10: Bar 0,0 to 1300,90:Locate ,1:Paper 10:Pen 1:Centre "Le renard a mangé le poulet !":Wait 2
    If MESSAGE = 5 Then Sam Play 2: Sprite 3,-100,490,5:Sprite 5,,,14:Ink 10: Bar 0,0 to 1300,90:Locate ,1:Paper 10:Pen 1:Centre "Le poulet a mangé le maïs !":Sam Play 2: Wait 2

    CLS 0

    If MESSAGE = 6 then Sam Play 1:Ink 10: Bar 0,0 to 1300,90:Locate ,1:Paper 10:Pen 1:Centre "Félicitations, vous avez réussi!": Wait 1 // Bravo: la foule applaudit

    Wait 0.5

    Locate ,12:Paper 0:Pen 1: Centre "Appuyez sur F5 pour recommencer"

    Wait 1

    STOPME=True // Indicateur logique (variable booléenne) utilisé pour arrêter le programme dans la boucle principale Do/Loop

  End proc

Previous Post Next Post