\documentclass[a4paper, 11p]{article}
\usepackage{graphicx}
\usepackage{color}
\usepackage{epsfig}

\usepackage[french]{babel}
\usepackage[utf8]{inputenc} 
\usepackage[T1]{fontenc}

\setlength{\hoffset}{-18pt}  	
\setlength{\oddsidemargin}{0pt} 	% Marge gauche sur pages impaires
\setlength{\evensidemargin}{9pt} 	% Marge gauche sur pages paires
\setlength{\marginparwidth}{54pt} 	% Largeur de note dans la marge
\setlength{\textwidth}{481pt} 		% Largeur de la zone de texte (17cm)
\setlength{\voffset}{-18pt} 		% Bon pour DOS
\setlength{\marginparsep}{7pt} 		% S\'eparation de la marge
\setlength{\topmargin}{0pt} 		% Pas de marge en haut
\setlength{\headheight}{0pt} 		% -13pt 	% Haut de page
\setlength{\headsep}{10pt} 			% Entre le haut de page et le texte
\setlength{\footskip}{27pt} 		% Bas de page + s\'eparation
\setlength{\textheight}{721pt} 		% +13 pt % Hauteur de la zone de texte (25cm)

\begin{document}
{\noindent}\begin{tabular}{|clrc|}\hline
&\multicolumn{2}{c}{{\bf EXAMEN D'INITIATION AUX INTERFACES GRAPHIQUES}}												&\\
&{\bf Institut Galil\'ee - Universit\'e Paris~13}\hspace*{3.5cm} 	&{\bf Lundi 11 juin 2012 -- 14h-16h}					&\\
&{\bf Licence~1}													&{\bf Aucun document autoris\'e}	&\\
\hline
\end{tabular}

\section{Puissance 4}

\subsection{Le jeu}
Le jeu de puissance 4 se joue entre deux joueurs sur une grille constituée de 6 rangées et 7 colonnes. Un joueur est gagnant s'il parvient le premier à aligner 4 de ses pions successivement sur une ligne, une colonne ou une diagonale de la grille. Les deux joueurs jouent chacun leur tour. Un tour pour un joueur consiste à choisir la colonne où placer son pion~: le pion se place alors dans la case la plus basse qui ne contient pas de pion. La partie est ex-{\ae}quo si aucun joueur ne gagne et que toutes les cases sont remplies. Exemples de parties gagnées par un joueur~:

$$\begin{array}{ccc}
	\begin{array}{|c|c|c|c|c|c|c|}
			&	&	&	&	&	&	\\\hline
			&	&	&	&	&	&	\\\hline
			&	&	&{\bf 1}	&	&	&	\\\hline
			&	&{\bf 1}	&2	&	&	&	\\\hline
			&{\bf 1}	&2	&1	&	&	&	\\\hline
		{\bf 1}	&2	&1	&2	&	&	&2	\\\hline
	\end{array}
	&\begin{array}{|c|c|c|c|c|c|c|}
			&	&	&	&	&	&	\\\hline
			&	&	&	&	&	&	\\\hline
			&	&1	&	&	&	&	\\\hline
			&{\bf 2}	&{\bf 2}	&{\bf 2}	&{\bf 2}	&	&	\\\hline
		2	&1	&1	&1	&2	&	&	\\\hline
			1	&1	&2	&2	&1	&1	&	\\\hline
	\end{array}
	&\begin{array}{|c|c|c|c|c|c|c|}
			&	&	&	&	&	&	\\\hline
			&	&	&{\bf 2}	&	&	&	\\\hline
		2	&1	&	&{\bf 2}	&	&	&	\\\hline
		1	&2	&	&{\bf 2}	&	&1	&	\\\hline
		1	&2	&	&{\bf 2}	&1	&2	&	\\\hline
		1	&2	&1	&1	&2	&1	&1	\\\hline
	\end{array}\\
	\textrm{Joueur 1 gagne en diagonale}
	&	\textrm{Joueur 2 gagne en ligne}
	&	\textrm{Joueur 2 gagne en colonne}
\end{array}$$

\subsection{Biblioth\`eque ``puissance 4'' fournie}
Vous disposez d'une biblioth\`eque~C du jeu de puissance~4, dont le fichier d'entête est joint au sujet. Les structures de données et les méthodes sont documentées dans ce fichier. Précisons quelques points~:

~\\{\noindent}$\bullet$ {\em Gestion du champ `joueur' de la structure `jeu\_p4'.} Le joueur~1 commence toujours la première partie. Ensuite, c'est le joueur qui n'a pas commencé la partie précédente qui commence une nouvelle partie. Pour gérer le cas d'une première partie, le modèle prévoit la fonction `p4\_new' qu'il faut appeler dés que l'on déclare une variable `p4\_jeu' et qui initialise certains de la structure, afin ensuite de pouvoir proprement décider quel joueur devra entamer la partie. C'est ensuite la fonction `p4\_init' qui met à jour la structure pour entamer une nouvelle partie, et donc en particulier le joueur qui doit jouer (cette fonction s'appuie pour cela sur les champs `joueur' et `nbcoup' de la structure `p4\_jeu').

~\\{\noindent}$\bullet$ {\em Indice des cases.} Les rangées sont indicées de 0 à NB\_LIG (de haut en bas), les colonnes sont indicées de 0 à NB\_COL (de gauche à droite). Les cases sont stockées dans un tableau unidimensionnel. La case se situant à l'intersection de la ligne $i$ et de la colonne $j$ est donc d'indice $(i*$NB\_COL$)+j$ dans ce tableau.

~\\{\noindent}$\bullet$ {\em Fonction `p4\_jouercoup'.} Cette fonction permet de jouer un coup. Elle utilise une fonction qui n'apparaît pas dans le fichier d'entête car elle est une sous-routine qui n'est déclarée et définie que dans le fichier source. Cette fonction, dont le prototype est \texttt{void p4\_testercoup(p4\_jeu* jeu, int i, int j);} et qui teste si le dernier coup joué est vaiqueur, est documentée comme suit~:\\
	\texttt{/* Vérifie et met à jour l'état de la partie à l'issue d'un coup joué.\\ 
		Pré-conditions : 0<=i<=NB\_LIG -1, 0<=j<= NB\_COL -1, la case (i,j) est jouée par jeu->joueur \\
		Post-conditions :\\
			- si jeu->joueur == ETAT\_CASE\_J1 et que le joueur remporte la partie, l'état de la partie est mis à jour à ETAT\_JEU\_J1\\
			- si jeu->joueur == ETAT\_CASE\_J2 et que le joueur remporte la partie, l'état de la partie est mis à jour à ETAT\_JEU\_J2\\
			- si la partie est ex-aequo, l'état de la partie est mis à jour à ETAT\_JEU\_J12	*/\\
		static void p4\_testercoup(p4\_jeu* jeu, int i, int j);
	}

\newpage
\section{Prise en mains de la biblioth\`eque ``puissance 4''}

\begin{enumerate} 
	\item Suite \`a une mauvaise manipulation, il faut r\'e\'ecrire certaines fonctions de la biblioth\`eque ``puissance 4''. Il s'agit des fonctions \texttt{case\_get\_tour}, \texttt{case\_set}, \texttt{p4\_get\_joueur}, \texttt{p4\_get\_case\_etat} et \texttt{p4\_jouercoup}. Pour cette dernière fonction, vous devez faire appel à la sous-routine `p4\_testercoup'.

	\item Il manque certaines fonctionnalit\'es \`a la biblioth\`eque ``puissance 4''. Donner le prototype et \'ecrire le code de deux nouvelles fonctions~:

		\begin{enumerate} 
		\item La fonction \texttt{p4\_afficher} qui repr\'esente l'\'etat de la partie. Exemple d'affichage~:\\
			~\\\texttt{\begin{tabular}{|c|c|c|c|c|c|c|}
					&	&	&	&	&	&	\\
					&	&	&2	&	&	&	\\
				2	&1	&	&2	&	&	&	\\
				1	&2	&	&2	&	&1	&	\\
				1	&2	&	&2	&1	&2	&	\\
				1	&2	&1	&1	&2	&1	&1	\\
			\end{tabular}}\\

		\item La fonction \texttt{p4\_derouler} qui permet de retracer le d\'eroulement d'une partie en affichant, pour chaque coup jou\'e de 1 au nombre de coups jou\'es dans la partie en cours~: l'indice de colonne de la case jouée lors de ce coup, le joueur qui a joué ce coup. Exemple d'affichage~:\\
			~\\\texttt{\begin{tabular}{llll}
				coup 1:		&colonne 0	&joueur 1\\
				coup 2:		&colonne 1	&joueur 2\\
				coup 3:		&colonne 1	&joueur 1\\
				coup 4:		&colonne 6	&joueur 2\\
				coup 5:		&colonne 2	&joueur 1\\
				coup 6:		&colonne 3	&joueur 2\\
				coup 7:		&colonne 3	&joueur 1\\
				coup 8:		&colonne 3	&joueur 2\\
				coup 9:		&colonne 3	&joueur 1\\
				coup 10:	&colonne 2	&joueur 2\\
				coup 11:	&colonne 2	&joueur 1
			\end{tabular}}
		\end{enumerate} 
\end{enumerate} 

\newpage
\section{Interface graphique du jeu de Puissance 4}
Vous devez d\'evelopper l'interface graphique du jeu de puissance 4, en gtk. L'interface doit afficher la grille de jeu et indiquer dans son titre ``Tour du joueur 1'', ``Tour du joueur 2'', ``Partie remportée par le joueur 1'', ``Partie remportée par le joueur 2'' ou ``Partie ex-{\ae}quo'', selon l'état courant du jeu. Au cours d'une partie, elle doit permettre aux joueurs de spécifier la colonne dans laquelle ils souhaitent jouer. Lorsqu'un partie est finie, elle doit permettre aux joueurs de demander une nouvelle partie.

\begin{enumerate} 
	\item Composants graphiques (en s'appuyant sur un schéma)~:
		\begin{enumerate}
		\item Quels sont les objets graphiques impliqu\'es ({\em ex.}, 3 boutons, 2 libell\'es, etc.)~? {\em Considérez les composants dans leur intégralité~; ne tenez pas compte du libellé d'un bouton, du titre d'une fenêtre, etc.}  
		\item Comment ces objets sont-ils imbriqu\'es entre-eux ({\em ex.}, le bouton \texttt{toto} dans la fen\^etre \texttt{tata}, {\em etc.})~?
		\item Pour chaque imbrication d'un objet dans un autre, indiquer et justifier la fonction gtk \`a utiliser. Vous pouvez pour cela donner le prototype de la fonction si vous le connaissez, ou simplement d\'ecrire la fonction, l'objet gtk sur lequel elle est d\'efinie, sa vocation, ses param\`etres essentiels.  
		\end{enumerate}

	\item Leur comportement~: 
		\begin{enumerate}
		\item Indiquer pour chaque composant pouvant interagir avec l'utilisateur son \'etat d'activit\'e en fonction de l'\'etat du jeu.
		\item Indiquer pour chaque libell\'e (dont le titre de la fenêtre, le contenu d'une zone de saisie, {\em etc.}) l'\'evolution de sa valeur en fonction de l'\'etat du jeu.
		\end{enumerate}

	\item Sollicitations faites au mod\`ele~:
		\begin{enumerate}
		\item Quelle(s) fonction(s) de la biblioth\`eque ``puissance 4'' faut-il appeler pr\'ealablement au lancement de l'interface graphique~?
		\item Quelle(s) fonction(s) de la biblioth\`eque ``puissance 4'' faut-il appeler lorsque sur l'interface, le joueur a choisi de jouer une colonne~?
		\item Quelle(s) fonction(s) de la biblioth\`eque ``puissance 4'' faut-il appeler lorsque sur l'interface, l'utilisateur demande une nouvelle partie~?
		\end{enumerate}

	\item Comment faire en sorte que votre interface ait le comportement d\'ecrit dans les r\'eponses pr\'ec\'edentes~? Indiquer~:
		\begin{enumerate}
		\item le prototype et la vocation des fonctions que vous envisagez devoir \'ecrire (mais sans \'ecrire les fonctions)~;
		\item l'ensemble des appels que vous envisagez de faire \`a la fonction \texttt{gtk\_signal\_connect}~;
		\item les \'eventuelles structures de donn\'ees que vous envisagez de d\'efinir pour faire appel \`a ces fonctions.
		\end{enumerate}	
\end{enumerate}

\newpage
\section{Langage C et gtk}
\begin{enumerate}
\item Le programme suivant produit une erreur \`a la compilation~; quelles sont les instructions fautives~?\\

		~\\\texttt{\begin{tabular}{ll}
		1&\#include $<$gtk/gtk.h$>$\\
		2&int main (int argc, char *argv{[}{]})\\
		3&\{\\
		4&$\ \ \ \ $GtkWindow* pFenetre = NULL;\\
		5&$\ \ \ \ $gtk\_init(NULL, NULL);\\
		6&$\ \ \ \ $pFenetre = gtk\_window\_new(GTK\_WINDOW\_TOPLEVEL);\\
		7&$\ \ \ \ $gtk\_window\_set\_title(pFenetre, "toto");\\
		8&$\ \ \ \ $gtk\_widget\_show\_all(GTK\_WIDGET(pFenetre));\\
		9&$\ \ \ \ $gtk\_main();\\
		10&$\ \ \ \ $return 0;\\
		11&\}\\
		\end{tabular}}\\

\item Le programme suivant compile, mais produit des erreurs \`a l'ex\'ecution. Lesquelles, et pourquoi~?\\
		~\\\texttt{\begin{tabular}{ll}
		1&\#include $<$gtk/gtk.h$>$\\
		2&int main (int argc, char *argv{[}{]})\\
		3&\{\\
		4&$\ \ \ \ $GtkWidget* pFenetre = NULL;\\	
		5&$\ \ \ \ $GtkWidget* pBoutonQuitter = NULL;\\
		6&$\ \ \ \ $gtk\_init(NULL, NULL);\\
		7&$\ \ \ \ $pFenetre = gtk\_window\_new(GTK\_WINDOW\_TOPLEVEL);\\
		8&$\ \ \ \ $pBoutonQuitter = gtk\_label\_new("\_Quitter");\\
		9&$\ \ \ \ $gtk\_container\_add(GTK\_CONTAINER(pFenetre), pBoutonQuitter);\\
		10&$\ \ \ \ $gtk\_window\_set\_title(GTK\_WINDOW(pFenetre), "tata (pour changer)");\\
		11&$\ \ \ \ $gtk\_button\_set\_label(GTK\_BUTTON(pBoutonQuitter), "titi (soyons fous !)");\\
		12&$\ \ \ \ $gtk\_widget\_show\_all(GTK\_WIDGET(pFenetre));\\
		13&$\ \ \ \ $gtk\_main();\\
		14&$\ \ \ \ $return 0;\\
		15&\}\\
		\end{tabular}}
\end{enumerate}

\end{document}
