libSCII/DOCS_fr.md

197 lines
9.2 KiB
Markdown
Raw Permalink Normal View History

2023-01-07 00:18:51 +01:00
# 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
2023-01-07 20:11:29 +01:00
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
2023-01-07 00:18:51 +01:00
```
* `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.
2023-01-07 00:39:11 +01:00
* `screen_height` est un `int` qui contient la hauteur de l'écran en nombre de caractères.
2023-01-07 20:11:29 +01:00
* `portrait_width` la largeur des portraits qui peuvent s'afficher à côté du texte.
2023-01-07 00:39:11 +01:00
## `world`, le monde du jeu
`world` est un dictionnaire qui contiendra tout les éléments du monde du jeu.
### Un exemple de `world`
```python
2023-01-07 11:27:45 +01:00
map0 = """
########################################################
# ________ \|/ #
# | ) | _|_ #
# |_)____| \_/ ______ #
# ^ [==-==-] _ #
# <=> [-===-=] // #
# / \ [==-==-] <=// #
# | || #
########################################################
"""
2023-01-08 12:20:03 +01:00
animations = {
"replace_animations": {
'-': {
"frames": ['=', '-'],
"animation_frame": 0
},
'=': {
"frames": ['-', '='],
"animation_frame": 0
}
},
"coords_animations": {
"4, 4": {
"frames": ['^', ' '],
"animation_frame": 0
}
}
}
2023-01-07 00:39:11 +01:00
world = {
"dmode": STICKY,
"map_num": 0,
"maps": [
{
"layers": [
{
"data": map0,
2023-01-08 12:20:03 +01:00
"transp_char": None,
"animations": animations
2023-01-07 00:39:11 +01:00
}
],
"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
2023-01-07 11:27:45 +01:00
2023-01-07 00:39:11 +01:00
* `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 :
2023-01-08 12:20:03 +01:00
* `layers` : les différentes couches qui constituent les maps. Ces layers sont dessinés du premier au dernier.
2023-01-07 12:45:10 +01:00
* `data` : Une string qui contient le layer (`map0` dans l'exemple).
2023-01-07 00:39:11 +01:00
* `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é.
2023-01-08 12:20:03 +01:00
* `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`.
2023-01-07 00:39:11 +01:00
* `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.
2023-01-08 12:20:03 +01:00
* `isactive` : Booléen : est ce que ce jump peut téléporter le joueur ?
2023-01-07 11:27:45 +01:00
* `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.
2023-01-08 12:20:03 +01:00
* `collision_check` : Booléen : est ce qu'on peut entrer en collision avec eux.
2023-01-07 11:27:45 +01:00
* `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.
2023-01-08 12:20:03 +01:00
* `collision_check` : Booléen : est ce qu'il est stoppé par les objets durs et les pnj.
2023-01-07 11:27:45 +01:00
* `layer` : Au dessus de quel layer ils s'affiche.
2023-01-07 12:45:10 +01:00
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.
2023-01-08 12:20:03 +01:00
* Déjà utilisés dans mainloop :
2023-01-07 12:45:10 +01:00
* `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`)
2023-01-08 12:20:03 +01:00
* `show_player` : Booléen : est ce que le joueur doit être affiché.
2023-01-07 12:45:10 +01:00
* `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.
2023-01-07 20:11:29 +01:00
* `portrait` (**Optionnel**) : Affiche un portrait à côté du texte.
2023-01-07 12:45:10 +01:00
* `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.
2023-01-08 12:20:03 +01:00
* `choices` : Liste de chaînes de caractères des choix que l'utilisateur.
* `portrait` (**Optionnel**) : Affiche un portrait à côté du texte.