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 = {"left": '4', "right": '6', "up": '8', "down": '2', "quit": 'q', "old_messages": '0'}, get_input_text = None, no_collision = " ^", collision_checker = None, message_history_max = 20, screen_width = 21, screen_height = 7, portrait_width = 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.
• portrait_width la largeur des portraits qui peuvent s'afficher à côté du texte.

world, le monde du jeu

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

Un exemple de world

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

animations = {
  "replace_animations": {
    '-': {
      "frames": ['=', '-'],
      "animation_frame": 0
    },
    '=': {
      "frames": ['-', '='],
      "animation_frame": 0
    }
  },
  "coords_animations": {
    "4, 4": {
      "frames": ['^', ' '],
      "animation_frame": 0
    }
  }
}

world = {
  "dmode": STICKY,
  "map_num": 0,
  "maps": [
    {
      "layers": [
        {
          "data": map0,
          "transp_char": None,
          "animations": animations
        }
      ],
      "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 constituent 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é.
    • animations (Optionnel) : Dictionnaire qui permet d'ajouter des animations à la map constitué de :
      • replace_animations : Dictionnaire pour les animations où un caractère est remplacé par un autre sur toute la map. Pour chaque caractère qui doit être animé, il faut y ajouter un autre dictionnaire où le nom est le caractère qui doit être animé. Ces dictionnaires sont constitués de :
        • frames : Liste qui contient les différent caractères qui constituent l'animation.
        • animation_frame : Quel caractère de l'animation va être affiché. C'est une position dans frames.
      • coords_animations : Dictionnaire pour les animations où un caractère est remplacé par un autre uniquement à une position bien précise. Pour chaque position qui doit être animée, il faut y ajouter un autre dictionnaire où le nom est "x, y" où x doit être remplacé par l'abscisse et y par l'ordonnée du caractère qui doit être animé. Ces dictionnaires sont constitués de :
        • frames : Liste qui contient les différent caractères qui constituent l'animation.
        • animation_frame : Quel caractère de l'animation va être affiché. C'est une position dans frames.
  • 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 : Boolé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 : Boolé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 : Boolé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à utilisé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 : Boolé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.
    • portrait (Optionnel) : Affiche un portrait à côté du texte.
  • 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 chaînes de caractères des choix que l'utilisateur.
    • portrait (Optionnel) : Affiche un portrait à côté du texte.