Aevilia - Système de menus

AEVILIA
Description du système de menus
Version 0.0.2

Démo technique : https://dl.dropboxusercontent.com/u/54952583/Aevilia_0.0.1.tar.gz
(Attention : compilée pour Linux)


Le système de menus a été construit pour être simple à utiliser, sans que l'implémentation relève du kamoulox.
Premier aspect : le chaînage des menus. Chaque menu est défini par la structure suivante :
typedef struct Menu Menu;
struct Menu {
	PosPixel						positionVert;
	PosPixel						positionHoriz;
	unsigned int					tailleVert;
	unsigned int					tailleHoriz;
	unsigned char					texte[256];
	Commande*						commande; // Commande à exécuter.
	Commande*						prochaineCommande; // Pour se souvenir de quelle est la commande actuelle.
	Menu*							prochainMenu; // Le prochain menu à rendre. Peut ne pas être initialisé à NULL, mais alors doit pointer vers une structure Menu.
};
Les champs positionVert et positionHoriz définissent les coordonnées - en pixels - du coin haut-gauche du menu.
Les champs tailleVert et tailleHoriz définissent les dimensions - en tiles - du menu. Je n'ai jamais essayé de rendre ces valeurs nulles, mais ça me semble une mauvaise idée.
Ces quatre champs permettent de rendre la structure de base du menu (à savoir son contour, plus de rendre l'intérieur du contour blanc). Ce travail est effectué par la fonction void rendreMenu(Menu* menu).
Le champ suivant est une chaîne de caractères affichée par le menu. Puisque le menu est réaffiché à chaque frame, il n'est pas possible à un module externe d'afficher une chaîne de caractères : elle serait détruite à la frame suivante.
Le champ prochainMenu est ce qui permet le chaînage des menus. Voici la fonction de gestion des menus :
void activerMenus(void) {
	Menu* pointeur = menuArendre;
	if(pointeur == NULL) {
		return;
	}
	rendreMenu(pointeur);
	while(pointeur->prochainMenu != NULL) {
		pointeur = pointeur->prochainMenu;
		rendreMenu(pointeur);
	}
	(...)
}
Ce qu'il y a entre les parenthèses concerne la gestion des Commandes. Nous verrons cela plus tard.
menuArendre est une variable globale (vous aurez deviné qu'elle est de type Menu*), qui sert de point de départ au chaînage des menus.
La fonction recherche d'abord si il existe au moins un menu, sinon elle quitte tout de suite.
Ensuite, elle effectue le rendu de ce menu, puis tant qu'il existe un menu suivant, elle passe au suivant, puis l'affiche.
On notera qu'à la sortie de la boucle, pointeur pointe vers le dernier menu de la chaîne.

Voici ce qui était caché par les parenthèses :
void activerMenus(void) {
	(...)
	Commande* cmd = pointeur->prochaineCommande;

	if(cmd != NULL) {
		// On exécute la commande du menu.
		if(commandes[cmd->commande](cmd) == 0) {
			// La fonction indique qu'elle a terminé. On passe à la commande suivante.
			pointeur->prochaineCommande = cmd->suivante;
		}
	} else {
		// Il n'y a plus de commandes à exécuter.
		pointeur->prochaineCommande = pointeur->commande;
		retirerMenu();
	}
}
Ce morceau de la fonction quitte la partie graphique, et s'occupe du traitement des commandes du menu.
Nous devons d'abord nous intéresser à la structure Commande :
// Une commande envoyée au moteur textuel.
typedef struct Commande Commande;
struct Commande {
	IDCommande						commande; // Indique quelle commande doit être exécutée, par sa clé.

// Arguments à la commande.
	void*							pointeur;
	void*							pointeur2;

	unsigned int					compteur;
	unsigned int					compteur2;

	unsigned int					(*fonction)();

	Commande*						suivante; // Pointe vers la prochaine commande à exécuter. NULL signifie "fin".
};
IDCommande est une enum, donnée ci-dessous. La structure Commande devant servir à différentes opérations, ses champs sont très génériques. Pour vous en donner une idée, voici
Voici la définition de l'enum IDCommande :
typedef enum {
#define CMD_CHAINE(chaine, suivante)					{CHAINE, chaine, NULL, 0, 0, NULL, suivante}
	CHAINE, // Afficher une chaîne.

#define CMD_ATTENDRE(attente, suivante)					{ATTENDRE, NULL, NULL, attente, 0, NULL, suivante}
	ATTENDRE, // Attendre un certain nombre de frames.

#define CMD_FONCTION(fonction, suivante)				{FONCTION, NULL, NULL, 0, 0, fonction, suivante}
	FONCTION, // Écrire un octet en mémoire.

#define CMD_SAUTER_COND(condition, branche, suivante)	{SAUTER, branche, suivante, 0, 0, condition, NULL}
#define CMD_SAUTER(branche)								CMD_SAUTER_COND(NULL, branche, NULL)
	SAUTER, // Continuer la lecture autre part.

#define CMD_APPELER_COND(condition, branche, suivante)	{APPELER, branche, branche, 0, 0, condition, suivante}
#define CMD_APPELER(branche, suivante)					CMD_APPELER_COND(NULL, branche, suivante)
	APPELER, // Appeler d'autres commandes (comme le fait SAUTER) puis revenir ici.

#define CMD_AJOUTER_MENU(menu, suivante)				{AJOUTER_MENU, menu, NULL, 0, 0, NULL, suivante}
	AJOUTER_MENU // Ajouter un autre menu par-dessus celui-ci.
} IDCommande;
A chaque commande est associée une macro, qui permet de définir plus clairement une commande en fonction de l'action qu'elle va réaliser.

Et voici un exemple de menu :
unsigned char chaineTest[] = {2, 2, 3, 4, 5, 6, BLANC, '\0'};
Commande commandeTest5 = CMD_ATTENDRE(180, NULL);
Commande commandeTest4 = CMD_SAUTER(&commandeTest5);
Commande commandeTest3 = CMD_CHAINE(chaineTest, &commandeTest4);
Commande commandeTest2 = CMD_ATTENDRE(180, &commandeTest3);
Commande commandeTest1 = CMD_CHAINE(chaineTest + sizeof(char), &commandeTest2);
Menu menuTest = MENU(7, 50, 5, 5, &commandeTest1);

Ce menu affiche une chaîne de caractères, attend 180 frames, affiche une autre chaîne de caractères, attend 180 frames, et se ferme.



Fonctionnement individuel de chaque type de Commande

CMD_CHAINE
Ajoute  (en fait, liste de tiles) à la chaîne du dernier menu ouvert. Copie jusqu'au prochain '\0', sans vérification de longueur. Aucun métacaratère, aucun délai. Ne sera affichée qu'à la frame suivante.

CMD_ATTENDRE
Ne fait rien pendant attente frames.

CMD_FONCTION
Appelle la fonction fonction passée en argument.

CMD_SAUTER_COND
Exécute la fonction condition. Si elle renvoie une valeur nulle, aller à suivante. Sinon, aller à branche. NULL n'est jamais exécuté, et "renvoie" toujours un.
CMD_SAUTER
Va à branche. Quasi-équivalent à CMD_ATTENDRE(1, branche), mais probablement plus lent.

CMD_APPELER_COND
Exécute la fonction condition (sauf si elle vaut NULL), et si elle renvoie une valeur non-nulle (c'est toujours le cas pour NULL), exécute la Commande branche puis les suivantes jusqu'à tomber sur un NULL, puis continue l'exécution à la Commande suivante.
En pratique, exécute le script de la fonction branche, puis de chacune des suivantes, et déclare avoir terminé lorsqu'elle trouve un NULL.
Les appels récursifs sont prohibés, car ils causent des erreurs sur les appels de niveau non-maximal. tl;dr : ça fait buguer.
CMD_APPELER
Même effet que CMD_APPELER_COND, mais exécute branche et le reste sans condition.

CMD_AJOUTER_MENU
Ajoute le menu menu par-dessus le dernier. Son script démarrera à la frame suivante.
NB : le script du menu courant est "mis en pause" (simplement, il cesse d'être exécuté) en attendant. Notez quand même que l'exécution du script du nouveau menu peut causer des appels récursifs.