[Java's cool] utilisation simultanée de deux proglets

Bonsoir tout le monde, j'ai un problème dans un programme de pendu que j'ai créer de A à Z pour le bac d'ISN,

je dois utiliser à la fois des fonctions des proglets DetectionFormes et TxtCode, et je n'ai pas d'erreurs lors de la compilation. En revanche, quand j'essaie de dessiner une image à partir de txtcode, voilà le message d'erreur :

Erreur lors de l'exécution de la proglet
java.lang.RuntimeException: java.lang.ClassCastException: org.javascool.proglets.txtCode.Panel cannot be cast to org.javascool.proglets.detectionForme.Panel Fct [showImage : Impossible de charger Bufferedimage num 1
.main(JvsToJavaTranslated54.java:30)
.run(JvsToJavaTranslated54.java:113)


Aidez moi s'il vous plait, je dois finir ça pour lundi matin !
voilà mon code si besoin (désolé qu'il ne soit pas propre): import java.net.*;
import java.io. *;
import javax.swing. *;
import java.awt.Color;
import static org.javascool.proglets.javaProg.Functions. *;
import static org.javascool.proglets.detectionForme.Functions. *;


// Procédure : la potence et le "pendu" apparaissent progressivement en fonction du
//nombre d'erreurs.
void AffichageDuPendu (int erreurs, int nbEssais){
int nbEtapes=0,i=0,incrementation=18/nbEssais, reste=18-(incrementation*nbEssais);
createImage(1, 370, 370);
while (nbEtapes<=18){
if(i<nbEssais){
i++;
}
nbEtapes=nbEtapes+incrementation+reste;
reste=0;
for (int j=0;j<=nbEtapes;j++){
switch (j){
case 1 : drawFillRect(1, 130, 295, 5, 10, Color.black);
showImage(1);
break;
// Pied gauche potence
case 2 : drawFillRect(1, 215, 295, 5, 10, Color.black);
showImage(1);
break;
// Pied droit potence
case 3 : drawFillRect(1, 120, 290, 110, 5, Color.orange);
showImage(1);
break;
// Base potence
case 4 : drawFillRect(1, 130, 165, 5, 130, Color.orange);
showImage(1);
break;
// Barre verticale potence
case 5 : drawFillRect(1, 120, 165, 110, 5, Color.orange);
showImage(1);
break;
// Haut potence
case 6 : int Xa=150;
int Yb=185;
for (int n = 0; n < 7; n++){
drawSegment(1, Xa, 165, 130, Yb, Color.orange);
Xa++;
Yb++;
}
showImage(1);
break;
// Barre de renfort potence
case 7 : drawSegment(1, 200, 170, 200, 190, Color.magenta);
showImage(1);
break;
// Corde
case 8 : drawFillRect(1, 190, 285, 5, 5, Color.black);
showImage(1);
break;
// Coussinet gauche tabouret
case 9 : drawFillRect(1, 205, 285, 5, 5, Color.black);
showImage(1);
break;
// Coussinet droit tabouret
case 10 : drawFillRect(1, 190, 260, 5, 25, Color.orange);
showImage(1);
break;
// Pied gauche tabouret
case 11 : drawFillRect(1, 205, 260, 5, 25, Color.orange);
showImage(1);
break;
// Pied droit tabouret
case 12 : drawFillRect(1, 185, 260, 30, 5, Color.orange);
showImage(1);
break;
// Siège tabouret
case 13 : drawOval(1, 190, 190, 20, 20, Color.blue);
showImage(1);
break;
// Tête
case 14 : drawSegment(1, 200, 210, 200, 240, Color.blue);
showImage(1);
break;
// Tronc
case 15 : drawSegment(1, 185, 220, 200, 220, Color.blue);
showImage(1);
break;
// Bras gauche
case 16 : drawSegment(1, 200, 220, 215, 220, Color.blue);
showImage(1);
break;
// Bras droit
case 17 : drawSegment(1, 200, 240, 190, 260, Color.blue);
showImage(1);
break;
// Jambe gauche
case 18 : drawSegment(1, 200, 240, 210, 260, Color.blue);
showImage(1);
break;
// Jambe droite
}
}
}
}


//procédure gérant la quasi totalité de l'affichage à chaque tour, d'où le nombre important de paramètres.
void AffichageBasique(char tabLettreConnue[],int erreurs,boolean affichageLettresProp,int numLettre,char tabLettresProp[], boolean validationLettre, char lettreProp, int nbEssais){
clear();

// Affiche les lettres trouvées et les "_" au début du tour du joueur 2.
for (int i2 = 0; i2 < tabLettreConnue.length; i2 ++) {
print(tabLettreConnue[i2] + " ");
}

// Affiche le pendu en fonction du nombre d'erreurs, indique le nombre d'erreurs et
//le nombre de chances restantes.
println();
AffichageDuPendu(erreurs, nbEssais);//se référer à la ligne 1.
println();
println("Pour l'instant, tu as fait "+erreurs+" erreurs.");
println();
println("Il te reste "+(10-erreurs)+" chances.");

// Affichage des lettres proposées si le joueur 2 à demandé à afficher les lettres
//au début de la partie
if(affichageLettresProp==true) {
println();
print("Les lettres déjà proposées sont : ");
for(int i8 = 0; i8 < numLettre; i8++) {
print(tabLettresProp[i8]+" " );
}
println();
}

// Si la lettre est fausse, le programme l'indique à l'utilisateur.
//Ne prend pas effet pendant le premier tour.
if (validationLettre==false&&erreurs>0){
println();
println("Désolé, la lettre '"+lettreProp+"' ne fait pas partie du mot à deviner.");
}
println();
}


//Procédure gérant l'affichage de fin du jeu.
void FinDuJeu(int erreurs, char tabMotMystere[],String pseudonyme2, int nbEssais){
clear();

// Sachant que la boucle arrête de tourner lorsque le nombre de lettres validées est
//égal au nombre de lettres du mot mystère, si toutes les lettres ont été trouvées
//et que le nombre d'erreurs est inférieur à neuf, le programme s'arrêtera sur
//l'affichage du mot mystère, l'annonce de la victoire du joueur 2 ...
if(erreurs<9){
print("Bravo "+pseudonyme2+ "! C'était bien le mot '");
for (int i7 =0; i7 < tabMotMystere.length; i7 ++){
print(tabMotMystere[i7]);
}
print("' !");

//...ou de sa défaite, si le nombre d'erreurs est supérieur à neuf.
}else{
AffichageDuPendu(erreurs, nbEssais);//ligne 131
println();
print("Tu as perdu "+pseudonyme2+" ! C'était le mot '");
for (int i7 =0; i7 < tabMotMystere.length; i7 ++){
print(tabMotMystere[i7]);
}
print("' !");
}
}


// Fonction : demande du mot mystère au joueur 1, retour d'une chaîne de caractères
//au programme principal.
String demandeMotMystere(int ChoixMode){
String motMystere=null;
if(ChoixMode==3) {
motMystere = readString("Proposant, entre le mot que tu veux faire deviner à ton adversaire");
} else {
println("Un mot va maintenant être choisi aléatoirement parmis tous ceux de la langue francaise.");
try {
URL url = new URL ("http://www.pallier.org/ressources/dicofr/liste.de.mots.francais.frgut.txt");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.connect();
BufferedReader rd = new BufferedReader(new InputStreamReader(connection.getInputStream()));
int NLigneBDD=random(1,336531);
for(int Lecture = 0; Lecture < NLigneBDD; Lecture++) {
motMystere=rd.readLine();
}
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
} else {
}
} catch (MalformedURLException e) {
} catch (IOException e) {

}
}
clear();
println("Le mot est entré, le jeu va commencer !");
sleep(2000);
return motMystere;
}

//Fonction tour du joueur
void TourDuJoueur(char lettreProp, char tabLettresProp[], boolean validationLettre,
int numLettre, char tabMotMystere[], char tabLettreConnue[], int nombreLettresValidees, int erreurs,
String pseudonyme2, boolean bonMot, boolean affichageLettresProp, int variables [][], int nbEssais){


println(pseudonyme2+" veux-tu rentrer une lettre ou un mot ?");
println();
println("Attention si tu choisis d'entrer un mot et qu'il est faux tu auras perdu !");
boolean choixJoueur = readBoolean("OUI pour une lettre et NON pour un mot.");
// S'il choisit d'entrer une lettre, le programme ouvre la boîte de dialogue permettant
//d'entrer un caractère.
if (choixJoueur == true) {
println();
lettreProp = readChar("Quelle lettre veux-tu rentrer ?");

// Cette boucle vérifie que la lettre proposée n'a pas déjà été entrée. Si c'est le cas
//l'utilisateur doit en entrer une autre.
for (int i3=0; i3<26; i3++){
while (lettreProp==tabLettresProp[i3]){
println();
lettreProp = readChar("Non, cette lettre a déjà été proposée ! Entre une autre lettre.");
}
}

// La variable de validation de la lettre proposée est réinitialisée.
validationLettre=false;

// La lettre proposée est entrée dans le tableau des lettres proposées.
tabLettresProp[numLettre]=lettreProp;

// Le nombre de lettres augmente.
numLettre++;

// Cette boucle vérifie si la lettre proposée fait partie du mot, ou pas.
for (int i4 =0; i4 < tabMotMystere.length; i4 ++) {

// Si c'est le cas, la lettre proposée est ajoutée au tableau des lettres connues,
//à son rang dans le mot. Le nombre de lettres validées augmente. La lettre est validée.
if (lettreProp == tabMotMystere[i4]) {
tabLettreConnue[i4] = lettreProp;
nombreLettresValidees++;
validationLettre=true;
}
FinDuJeu(erreurs, tabMotMystere, pseudonyme2, nbEssais);//voir ligne 201

}

// Si la lettre proposée n'est pas validée, le nombre d'erreurs s'incrémente.
if (validationLettre==false){
erreurs++;
}

// Ici, le joueur choisit d'enter un mot.
} else {
String motPropose = readString("Quel mot veux-tu rentrer ?");

// La chaîne de caractère est importée dans un nouveau tableau.
char tabMotPropose[] = motPropose.toCharArray();

// Si la longueur du mot mystère est différente de celle du mot proposé, le mot
//proposé est faux, le nombre d'erreurs passe directement à dix.
if(tabMotPropose.length!=tabMotMystere.length){
bonMot=false;
erreurs=10;

// Sinon, si la longueur du mot mystère est égale à celle du mot proposé, le mot
//proposé est vrai.
} else {
for (int i5 =0; i5 < tabMotMystere.length; i5 ++) {
if (tabMotPropose[i5] != tabMotMystere[i5]) {
erreurs=10;
bonMot=false;
}
}
}
bonMot=true;
FinDuJeu(erreurs, tabMotMystere, pseudonyme2, nbEssais);
}


if(bonMot==true) {
variables [0][0]=1;
} else {
variables [0][0]=0;
}
variables[1][0]=erreurs;
variables[2][0]=nombreLettresValidees;
variables[3][0]=numLettre;
if(validationLettre=true) {
variables [4][0]=1;
} else {
variables [4][0]=0;
}
variables[5][0]= (int)lettreProp;
for(int n = 0; n < tabMotMystere.length; n++) {
variables [n][2]=(int)tabMotMystere[n];
variables [n][3]=(int)tabLettreConnue[n];
}
for(int g = 0; g < 26; g++)
variables [g][1]=(int)tabLettresProp[g];
}

void main() {
int ChoixMode =0;
clear();
createImage(1, 370, 370);
clearImage(1);
while (ChoixMode <1 || ChoixMode >3) {
clear();
println("Choisissez un mode de jeu :");
println("1 pour mode 2 joueurs en alternance");
println("2 pour mode 1 joueur contre ordinateur");
println("3 pour mode 1 joueur proposant le mot à deviner");
println("et l'autre joueur le cherchant");
ChoixMode = readInteger("Choisissez votre mode de jeu");
}
int nbEssais=readInt("En combien d'essais voulez-vous jouer cette partie ? (maximum 18)");
int nombreLettresValidees=0, erreurs=0, numLettre=0;
boolean validationLettre=false, bonMot=false, affichageLettresProp=readBoolean("Voulez-vous afficher les lettres que vous proposerez en cours de partie ?");
char lettreProp='§';

// Création de trois tableaux : le premier est rempli avec les caractères du mot
//mystère. Le deuxième est défini sur la même longueur que le premier. Le troisième,
//celui des lettres proposés, a une longueur de 26 caractères (longueur de l'alphabet).
char tabMotMystere[] = demandeMotMystere(ChoixMode).toCharArray();//voir fonction ligne 149
char [] tabLettreConnue = new char [tabMotMystere.length];
char [] tabLettresProp = new char [26];
int variables[][] = new int [26][4];
// Cette boucle remplit le tableau des lettres connues par des '_' utilisés pour
//l'affichage.
for (int i1 = 0; i1 < tabMotMystere.length; i1 ++)
tabLettreConnue[i1] = '_';



//Affichage des pseudonymes
String pseudonyme1=readString("Choisis ton pseudonyme, joueur 1");
println("Bonne chance "+pseudonyme1+" !!!");
/////////////////////////////////////////////////////////////

if (ChoixMode ==1) {
int Njoueur=1;
String pseudonyme2=readString("Choisis ton pseudonyme, joueur 2");
println("Bonne chance "+pseudonyme2+" !!!");
} else {//////////////////////////////////////////////////////

// if(ChoixMode==2) {
// // CodeSiOui
// } else {/////////////////////////////////////////////////////
//
// }////////////////////////////////////////////////////////
while (nombreLettresValidees != tabMotMystere.length&&10>erreurs&&bonMot!=true){

//voir la procédure à la ligne 159
AffichageBasique( tabLettreConnue, erreurs, affichageLettresProp, numLettre, tabLettresProp,
validationLettre, lettreProp, nbEssais);

// Demande au joueur 2 s'il veut entrer un mot ou une lettre, stocke ce choix dans
//une variable.

TourDuJoueur(lettreProp, tabLettresProp, validationLettre, numLettre, tabMotMystere,
tabLettreConnue, nombreLettresValidees, erreurs, pseudonyme1, bonMot, affichageLettresProp, variables, nbEssais);

if(variables [0][0]==1) {
bonMot=true;
} else {
bonMot=false;
}
erreurs=variables[1][0];
nombreLettresValidees=variables[2][0];
numLettre=variables[3][0];
if(variables [4][0]==1) {
validationLettre=true;
} else {
validationLettre=false;
}
lettreProp= (char)variables[5][0];
for(int n = 0; n < tabMotMystere.length; n++) {
tabMotMystere[n]= (char)variables [n][2];
tabLettreConnue[n]=(char)variables [n][3];
}
for(int g = 0; g < 26; g++) {
tabLettresProp[g]= (char)variables [g][1];



}
}

}
}