Dans les dernières versions de Geogebra, il est possible de créer « exercices autocorrigés ».
Dans ces exercices, on vérifie qu'un objet créé par l'utilisateur de l'applet correspond bien à un objet demandé.

Il existe un système de booléen qui vérifie si un objet est bien créé. Mais il demande de refaire la manipulation à chaque fois. Et lorsque votre applet Geogebra est un peu ancienne, elle peut être plus complexe à modifier. Pour cela, nous allons tout automatiser et normaliser.
Bien évidemment, Geogebra suivant la nouvelle mode des WebApps, nous allons programmer cette fonctionnalité en Javascript.

Analyse d'un code très courant…

function ggbOnInit() {
	//ggbApplet.debug("ggbOnInit");
	ggbApplet.registerAddListener("newObjectListener");
}

function newObjectListener(obj) {
	if ( obj != "finished" ) {
		var cmd = "finished = ("+obj+"== target)";
		//ggbApplet.debug(cmd);
		ggbApplet.evalCommand(cmd);
		finished = ggbApplet.getValueString("finished");
		if (finished.indexOf("true") > -1) {
			ggbApplet.setVisible("wellDone",true);
		}
	} 
}

Tout d'abord commentons un peu ce script :
La première fonction ggOnInit définit ce qui doit se passer au tout début, à l'initialisation de l'application que nous construisons.
Les commandes spécifiques à Geogebra commencent toujours par ggbApplet. Pour des raisons de développement, on lui demande d'écrire les résultats et erreurs avec ggbApplet.debug( fonction ). Mais une fois finie, vous n'aurez plus besoin de ces fonctions.
Puis on ajoute un « écouteur d'événement ». Ici, écouteur d'ajout (d'objets geogebra dans le plan) que nous nommons newObjectListener (vous pouvez lui donner le nom que vous voulez) pour des raisons presque évidentes.

Ensuite nous devons définir ce que va faire cet écouteur.
Ne regardons pas encore la première ligne… Nous allons créer une commande Geogebra nommée cmd, que nous allons évaluer grâce à ggbApplet.evalCommand().
La commande finished = ("+obj+"== target) crée un booléen finished qui sera vrai si l'objet obj est le même que target.

Enfin, on demande que finished contienne le mot « true » (vrai) pour afficher l'objet nommé wellDone.

Bien, et vous vous souvenez de cette première ligne qu'on a passé ? if( obj != "finished" )
Elle servait à ne pas tester les booléens finished à chaque création. Cela créerait des conflits d'écriture et fait planter le script.

Bravo ! Votre script est prêt !

Aller plus loin… et tout automatiser.

Cependant, cela ne permet pas de rajouter d'autres constructions à vérifier.
Pour cela, on va créer une fonction testObject qui prendra deux paramètres : l'objet qu'on veut tester et le numéro du test.
On va alors créer des booléens finished1, finished2, etc qui vont vérifier si l'objet est target1, target2, etc. Le tout en vérifiant bien que l'on n'a pas affaire à un booléen.
Au final, on obtient ce code que je vous laisse observer dans une toute nouvelle version francisée :

function testObject(obj,n){
	// On teste si c'est un booléen "estCeFiniOuNon"
	if ( obj.indexOf( "estCeFiniOuNon" ) == -1 ) {
		// On évalue la commande de test
		var cmd = "estCeFiniOuNon"+n+" = ("+obj+"== bonneCible"+n+")";
		ggbApplet.evalCommand(cmd);
		// On récupère l'objet booléen de Geogebra
		finished = ggbApplet.getValueString("estCeFiniOuNon"+n);
		// On affiche la cible si le booléen est vrai
		if (finished.indexOf("true") > -1) {
			ggbApplet.setVisible("messageBonneReponse"+n,true);
		}
	} 
}

Il ne reste plus qu'à lancer la fonction testObject(obj, 1), pour tester si l'objet obj est la cible target1 grâce à un nouveau booléen finished1.
Il ne reste plus qu'à faire une boucle sur l'ensemble des cibles…

// Écouteur d'ajout d'objet :
function newObjectListener(obj) {
	// On crée une boucle sur l'ensemble des cibles
	for(var i=1; ggbApplet.exists("bonneCible"+i); i++ ){
		testObject(obj,i);
	}
}

Finalisation

Mis bout à bout, on obtient ce script complet que je vous conseille de mettre dans un fichier pour le copier dans tous vos programmes :

// Initialisation de Geogebra
function ggbOnInit() {
	// On crée un écouteur de création d'objet
	ggbApplet.registerAddListener("ecouteurDAjout");
	// On cache tous les messages laudatifs
	for(var i=1; ggbApplet.exists("messageBonneReponse"+i); i++ ){
		ggbApplet.setVisible("messageBonneReponse"+i,false);
	}
	// Dans le doute on cache aussi les cibles
	for(var i=1; ggbApplet.exists("bonneCible"+i); i++ ){
		ggbApplet.setVisible("bonneCible"+i,false);
	}
}

// Fonction de test obj == "bonneCible"+n
function testObject(obj,n){
	var finishedString="estCeFiniOuNon";
	// On vérifie qu'on n'est pas un booléen
	if ( obj.indexOf( finishedString ) == -1 ) {
		// On évalue la commande de test
		var cmd = finishedString+n+" = ("+obj+"== bonneCible"+n+")";
		ggbApplet.evalCommand(cmd);
		// On récupère l'objet booléen de Geogebra
		var finished = ggbApplet.getValueString(finishedString+n);
		// On affiche la cible si le booléen est vrai
		if (finished.indexOf("true") > -1) {
			ggbApplet.setVisible("messageBonneReponse"+n,true);
		}
	} 
}

// Écouteur d'ajout d'objet :
function ecouteurDAjout(obj) {
	// On crée une boucle sur l'ensemble des cibles
	for(var i=1; ggbApplet.exists("bonneCible"+i); i++ ){
		testObject(obj,i);
	}
}

Conclusion et perspectives

L'avantage de ce script est qu'il est facile à utiliser et à modifier.
Par exemple, pour créer des tests pour des « mauvais objets créés » pour signifier à l'élève une erreur courante. Ça peut être un report de longueur au mauvais endroit, le mauvais sommet principal dans un triangle rectangle ou isocèle, une symétrie par rapport à la mauvaise droite, une erreur de signe, etc.
On peut alors créer des objets pièges qui afficheront des messages d'alerte messagesMauvaiseReponse.

On peut aussi créer un bouton qui affiche un message « À l'aide » en gros et en rouge pour aider le professeur à voir immédiatement l'élève qui a besoin d'aide soit à distance via Geogebra Classroom, soit en classe pour éviter que les élèves ne crient dans tous les sens.

Voici un exemple d'une telle applet plus complète et facile à modifier.