# libSCII Pour utiliser libSCII, il faut créer une nouvelle variable de la classe Scii : ## La classe `Scii` ```python scii = Scii(world, player, npc_collision) ``` Voici les arguments qu'on peut donner à Scii : ```python 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` ```python 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` ```python 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.