libSCII/DOCS_fr.md

libSCII

Pour utiliser libSCII, il faut créer une nouvelle variable de la classe Scii :

La classe Scii

scii = Scii(world, player, npc_collision)

Voici les arguments qu'on peut donner à Scii :

world, player, on_npc_collision, scii_keys = None, get_input_text = None, no_collision = None, collision_checker = None, message_history_max = None, screen_width = 21, screen_height = 7

• world va contenir les données du monde. Des explication plus précises sont plus bas.
• player va conten les données du joueur. Des explication plus précises sont plus bas.
• on_npc_collision doit être une fonction avec les arguments self, npc qui est exécutée lorsque le joueur va vers le pnj.
  • self contient la classe Scii et permet d'y appeler des fonctions.
  • npc contient les données du pnj, comme elles sont écrites dans world (voir plus bas).
• scii_keys contient les touches que le joueur utilise pour faire certaines action. Quand scii_keys est égal à None, les touches utilisés sont : {"left": '4', "right": '6', "up": '8', "down": '2', "quit": 'q', "old_messages": '0'}. "old_messages" permet de voir les anciennes conversations.
• get_input_text est une fonction qui doit retourner une chaine de caractères qui sera affichée dans l'input pour récupérer les touches.
• no_collision est une chaine de caractères qui contient les caractères que le joueur peut traverser. Par défaut, lorsque no_collision est égal à None, la chaine de caractères est " ^".
• collision_checker est une fonction qui prend les paramètres self, world, player, x, y et qui retourne 0 si le joueur peut passer à (x, y), 1 si il ne peut pas passer à (x, y) et 2 si il y a un pnj à (x, y). self permet d'appeler des fonctions de la classe Scii ou à en récupérer des données et world et player contiennent les mêmes données que world et player qui sont des arguments de Scii.
• message_history_max contient le nombre de messages maximals qui seront conservés dans l'historique des conversations.
• screen_width est un int qui contient la largeur de l'écran en nombre de caractères.
• screen_height est un int qui contient la hauteur de l'écran en nombre de caractères.

world, le monde du jeu

world est un dictionnaire qui contiendra tout les éléments du monde du jeu.

Un exemple de world

map0 = """
########################################################
#  ________              \|/                           #
#  | )    |              _|_                           #
#  |_)____|              \_/         ______            #
#   ^                               [==-==-]       _   #
#               <=>                 [-===-=]      //   #
#               / \                 [==-==-]   <=//    #
#                                              | ||    #
########################################################
"""

world = {
  "dmode": STICKY,
  "map_num": 0,
  "maps": [
    {
      "layers": [
        {
          "data": map0,
          "transp_char": None
        }
      ],
      "jumps": [
        {
          "x": 4,
          "y": 4,
          "to_x": 1,
          "to_y": 1,
          "to_map": 0,
          "isactive": 1
        }
      ]
    }
  ],
  "npc": [
    {
      "x": 35,
      "y": 1,
      "isvisible": 1,
      "collision_check": 1,
      "layer": 0,
      "map": 0,
      "char": '&',
      "name": "massena"
    },
    {
      "x": 35,
      "y": 6,
      "isvisible": 1,
      "collision_check": 1,
      "layer": 0,
      "map": 0,
      "char": '&',
      "name": "lephenixnoir"
    }
  ]
}

Description

• dmode : La méthode d'affichage de la carte :
  • STICKY : Le joueur est au milieu à part si il est trop proche du bord de la carte, il va donc se décentrer.
  • CENTERED : Le joueur est toujours au centre (comme dans Asci).
  • BLOCKS : La carte s'affiche par portions (un peu comme c'est parfois le cas dans Megaman sur la NES).
  • STICKYBLOCKS : La carte s'affiche comme dans BLOCKS, mais elle remplit toujours l'écran.
• map_num : Le numéro de la carte sur laquelle on va démarrer le jeu.
• maps : Une liste de plusieurs cartes, chacune constituée de :
  • layers : les différentes couches qui contituent les maps. Ces layers sont dessinés du premier au dernier.
    • data : Une string qui contient le layer (map0 dans l'exemple).
    • transp_char : Le caractère qui ne sera pas affiché : permet de voir le layer d'en dessous. Si il est à None, aucun caractère ne sera enlevé.
  • jumps : Liste des endroits où le joueur peut sauter d'une map à l'autre et/ou d'une position à l'autre. Cette liste est constituée de dictionnaires constituées de :
    • x et y : La position de départ.
    • to_x et to_y : La position de d'arrivée.
    • to_map : La map de l'arrivée.
    • isactive : Bolléen : est ce que ce jump peut téléporter le joueur ?
• npc : Liste des pnj qui sont des dictionnaires constituée de :
  • x et y : Leur position sur la map.
  • isvisible : est ce qu'ils sont visibles.
  • collision_check : Bolléen : est ce qu'on peut entrer en collision avec eux.
  • layer : Au dessus de quel layer ils s'affichent.
  • map : Sur quelle map ils sont.
  • char : Quel caractère est utilisé pour les afficher.
  • name : Le nom du pnj, ce qui permet de l'identifier.

player, le joueur

Un exemple de player

player = {
  "x": 3,
  "y": 4,
  "isvisible": 1,
  "collision_check": 1,
  "layer": 0,
  "playerc": '@'
}

Description

• x et y : Sa position sur la map.
• isvisible : est ce qu'il est visible.
• collision_check : Bolléen : est ce qu'il est stoppé par les objets durs et les pnj.
• layer : Au dessus de quel layer ils s'affiche.

La map sur laquelle il est est déjà définie dans map_num de world.

Les fonctions de Scii

self est la classe Scii.

• mainloop(self) : Lance la boucle du jeu.
• Déjà uilisés dans mainloop :
  • get_map_width(self, map_data) : Retourne la largeur de la map.
    • map_data : dictionnaire de la map comme il est dans world["maps"]
  • get_map_height(self, map_data) : Retourne la hauteur de la map.
    • map_data : dictionnaire de la map comme il est dans world["maps"]
  • draw_map(self, mode, show_player)
    • mode : Mode de dessin de la map (STICKY, CENTERED, BLOCKS ou STICKYBLOCKS)
    • show_player : Bolléen : est ce que le joueur doit être affiché.
  • def show_text(self, text) : Affiche du texte. L'historique du texte affiché est disponible en appuyant sur scii_keys["old_messages"] ou en appelant show_old_messages(self).
    • text : Texte à afficher.
  • show_old_messages(self) : Affiche les anciennes conversations.
  • ask_choice(self, text, choices) : Demande à l'utilisateur de faire un choix parmi les choix proposés dans choices. Retourne le choix fait. Le premier choix est le numéro 1, et les prochains sont à chaque fois de 1 plus grands : dans ["Oui", "Non", "Je ne sais pas"] "Oui" est le choix numéro 1, "Non" est le choix numéro 2 et "Je ne sais pas" est le choix numéro 3.
    • text : Texte à afficher avant de demander à l'utilisateur quel proposition il fait. Les choix seront affichés en dessous.
    • choices : Liste de chaines de caractères des choix que l'utilisateur.