Le pendu, tétris, mastermind sur linux

merci donc ta pas de solution

c'est juste pour l'école tant pi merci

/*
* Tetris.java
*/

// <applet code=Tetris.class width=150 height=300> </applet>

import java.util.*;
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.Graphics.*;
import java.util.Random;

public class Tetris extends Applet implements Runnable, KeyListener {

public int [][] grille;
public int incide;
public int sleep_time=200;
boolean tourne_piece=false;
boolean va_gauche=false;
boolean va_droite=false;


Piece p;
Thread mon_process;

Image offI;//nécessaire à la méthode de double buffering
Graphics offG;//nécessaire à la méthode de double buffering


public void init() {

resize(150, 300);
// 10 colonnes, 24 lignes
grille = new int [10][24];

for (int i=0;i<10;i++) {
for (int j=0;j<20;j++) {
grille [i][j]=0;
}
}



for (int i=0;i<10;i++) {
grille [i][20]=1;
// grille [i][21]=1;
// grille [i][22]=1;
// grille [i][23]=1;
}

p = new Piece();
p.cree_piece();
p.affiche_piece(grille);
repaint();

// Ajout de l'écouteur de clavier
this.addKeyListener(this);

requestFocus();

}


// Démarrage de l'applet
public void start () {

if (mon_process == null) {
mon_process = new Thread(this);
mon_process.start();
}

}

// Arrêt de l'applet
public void stop () {

if (mon_process != null) {
mon_process.interrupt();
mon_process = null;
}

}


// double buffer

public void update(Graphics g)
{

if(offI == null)
{
offI = createImage(150, 300);
offG = offI.getGraphics();
}
offG.clearRect(0, 0, 150, 300);
paint(offG);
g.drawImage(offI, 0, 0, null);

}


public void paint (Graphics g) {

for (int k=0;k<10;k++) {
for (int l=0;l<20;l++) {
if (grille[k][l]==0) {
g.setColor(Color.white);
g.draw3DRect (15*k,15*l,15,15,true);
}
else
{
switch (grille[k][l]) {
case 1: g.setColor(new Color(0,192,0)); g.fill3DRect(15*k,15*l,15,15,true); break; //vert
case 2: g.setColor(Color.pink); g.fill3DRect(15*k,15*l,15,15,true); break; //rouge
case 3: g.setColor(new Color(0,128,224)); g.fill3DRect(15*k,15*l,15,15,true); break; //bleu
case 4: g.setColor(new Color(0,192,192)); g.fill3DRect(15*k,15*l,15,15,true); break; //cyan
case 5: g.setColor(Color.orange); g.fill3DRect(15*k,15*l,15,15,true); break; //orange
case 6: g.setColor(Color.darkGray); g.fill3DRect(15*k,15*l,15,15,true); break; //gris
case 7: g.setColor(Color.magenta); g.fill3DRect(15*k,15*l,15,15,true); break; //magenta
}
}
}
}

}

// L'interface KeyListener.

public void keyPressed(KeyEvent e) {
switch (e.getKeyCode()) {
case KeyEvent.VK_LEFT : if (p != null) {
p.gauche(grille);
repaint();
}
break;
case KeyEvent.VK_RIGHT : if (p != null) {
p.droite(grille);
repaint();
}
break;
case KeyEvent.VK_UP : if (p != null) {
p.tourned(grille);
repaint();
}
case KeyEvent.VK_DOWN : if (p != null) {
p.descend(grille);
repaint();
}
break;
default : repaint();
}
}

public void keyReleased(KeyEvent e) {
}

public void keyTyped(KeyEvent e) {
}


// Ce que le thread mon_process exécute
public void run()
{
// Boucle infinie (tant que mon_process existe et n'est pas interrompu)
while ((Thread.currentThread()==mon_process) && (! mon_process.isInterrupted()))
{
p.descend(grille);
//sleep_time=old_sleep_time;
// p.verifie_ligne(grille);
repaint();
try {
Thread.sleep(sleep_time);
}
catch (InterruptedException e) {
return;
}
}
}


}




class Piece
{

int numero;
int position = 0;
int x = 0;
int y = 0;
int x1 = 0;
int y1 = 0;

boolean b = false;


public int[][] Piece1 = { {0,1,0,0,0,1,1,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0},
{0,1,0,0,0,1,1,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0} };
public int[][] Piece2 = { {0,2,2,0,0,2,2,0,0,0,0,0,0,0,0,0},
{0,2,2,0,0,2,2,0,0,0,0,0,0,0,0,0},
{0,2,2,0,0,2,2,0,0,0,0,0,0,0,0,0},
{0,2,2,0,0,2,2,0,0,0,0,0,0,0,0,0} };
public int[][] Piece3 = { {0,3,0,0,0,3,0,0,0,3,0,0,0,3,0,0},
{3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0},
{0,3,0,0,0,3,0,0,0,3,0,0,0,3,0,0},
{3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0} };
public int[][] Piece4 = { {0,0,4,0,0,4,4,0,0,4,0,0,0,0,0,0},
{0,0,0,0,0,4,4,0,0,0,4,4,0,0,0,0},
{0,0,4,0,0,4,4,0,0,4,0,0,0,0,0,0},
{0,0,0,0,0,4,4,0,0,0,4,4,0,0,0,0} };
public int[][] Piece5 = { {0,5,0,0,0,5,5,0,0,5,0,0,0,0,0,0},
{0,0,0,0,0,0,5,0,0,5,5,5,0,0,0,0},
{0,0,0,5,0,0,5,5,0,0,0,5,0,0,0,0},
{0,5,5,5,0,0,5,0,0,0,0,0,0,0,0,0} };
public int[][] Piece6 = { {0,0,6,0,0,0,6,0,0,6,6,0,0,0,0,0},
{0,0,0,0,0,6,6,6,0,0,0,6,0,0,0,0},
{0,6,6,0,0,6,0,0,0,6,0,0,0,0,0,0},
{0,0,0,0,0,6,0,0,0,6,6,6,0,0,0,0} };
public int[][] Piece7 = { {0,7,0,0,0,7,0,0,0,7,7,0,0,0,0,0},
{0,0,0,0,0,0,0,7,0,7,7,7,0,0,0,0},
{0,7,7,0,0,0,7,0,0,0,7,0,0,0,0,0},
{0,0,0,0,0,7,7,7,0,7,0,0,0,0,0,0} };


public int [][] piecec = new int [4][16];


Piece() {
for (int i=0;i<4;i++) {
for (int j=0;j<16;j++) {
piecec [i][j]=0;
}
}
}

public void cree_piece() {

// numero est compris entre 1 et 4

numero = (int)(Math.random() * 100);
numero = (numero % 7) + 1;

numero = 1 + ((int)(Math.random()*7));

/* Random generateur = new Random();

// Get an integer
int number = (generateur.nextInt());

// Accept only up to ten
numero = number % 4;
if (numero < 1) numero = numero + 4; */

switch (numero) {
case 7: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece7 [i][j]; }}; break;
case 6: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece6 [i][j]; }}; break;
case 5: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece5 [i][j]; }}; break;
case 4: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece4 [i][j]; }}; break;
case 3: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece3 [i][j]; }}; break;
case 2: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece2 [i][j]; }}; break;
case 1: for (int i=0;i<4;i++) { for (int j=0;j<16;j++) { piecec [i][j]=Piece1 [i][j]; }}; break;
}

}

public void gauche(int[][] g) {
efface(g);

x--;

if (bloque_gauche(g)) x++;
affiche_piece(g);
}

public void droite(int[][] g) {
efface(g);

x++;

if (bloque_droite(g)) x--;
affiche_piece(g);
}


public boolean bloque_droite(int[][] g)
{
boolean d = false;
for (int m=0;m<16;m++) {
// La case de la pièce est-elle remplie ?
if (piecec[position][m] != 0) {
int x1 = m % 4; // colonne de la pièce
int y1 = m / 4; // Ligne de la pièce
if ((x+x1) > 9) return true;
else {
if (g[x+x1][y+y1] != 0) return true;
}
}

}

return d;
}

public boolean bloque_gauche(int[][] g)
{
boolean d = false;
for (int m=0;m<16;m++) {
// La case de la pièce est-elle remplie ?
if (piecec[position][m] != 0) {

x1 = m % 4; // colonne de la pièce
y1 = m / 4; // Ligne de la pièce

if ((x+x1) < 0 ) return true;
else {
if (g[x+x1][y+y1] != 0) return true;
}
}

}

return d;
}

public void tourned(int[][] g) {
efface(g);
int old = position;
position ++;
if (position ==4) position=0;

if (bloque_tourne(g)) position = old;

if (bloque(g)) position = old;
affiche_piece(g);
}

public boolean bloque_tourne(int[][] g)
{
boolean d = false;
for (int m=0;m<16;m++) {
// La case de la pièce est-elle remplie ?
if (piecec[position][m] != 0) {

x1 = m % 4; // colonne de la pièce
y1 = m / 4; // Ligne de la pièce

if ((x+x1) > 9 ) return true;

if ((x+x1) < 0 ) return true;
else {
if (g[x+x1][y+y1] != 0) return true;
}
}

}

return d;
}


public void affiche_piece(int[][] g)
{

for (int m=0;m<4;m++)
if ( ((x+m)<10) && ((x+m)>=0) && (g[x+m][y]==0) && (piecec[position][m] != 0))
g[x+m][y] = piecec[position][m];

if ((y+1)<24)
for (int m=0;m<4;m++)
if ( ((x+m)<10) && ((x+m)>=0) && (g[x+m][y+1]==0) && (piecec[position][m+4] != 0))
g[x+m][y+1] = piecec[position][m+4];

if ((y+2)<24)
for (int m=0;m<4;m++)
if ( ((x+m)<10) && ((x+m)>=0) && (g[x+m][y+2]==0) && (piecec[position][m+8] != 0))
g[x+m][y+2] = piecec[position][m+8];

if ((y+3)<24)
for (int m=0;m<4;m++)
if ( ((x+m)<10) && ((x+m)>=0) && (g[x+m][y+3]==0) && (piecec[position][m+12] != 0))
g[x+m][y+3] = piecec[position][m+12];

}


public boolean bloque(int[][] g)
{
boolean c = false;

for (int m=0;m<4;m++) {
if (((x+m)<10) && (y < 24) && ((x+m)>=0))
if ((g[x+m][y]!=0) && (piecec[position][m]!=0)) return true;
}
for (int m=0;m<4;m++) {
if (((x+m)<10) && (y < 23) && ((x+m)>=0))
if ((g[x+m][y+1]!=0) && (piecec[position][m+4]!=0)) return true;
}
for (int m=0;m<4;m++) {
if (((x+m)<10) && (y < 22) && ((x+m)>=0))
if ((g[x+m][y+2]!=0) && (piecec[position][m+8]!=0)) return true;
}
for (int m=0;m<4;m++) {
if (((x+m)<10) && (y < 21) && ((x+m)>=0))
if ((g[x+m][y+3]!=0) && (piecec[position][m+12]!=0)) return true;
}
//}

return c;
}


public void verifie_ligne(int[][] g) {

for (int m=0;m<20;m++) {
b=false;
for (int n=0;n<10;n++)
{
if (g[n][m] == 0) b=true;
}

if (b==false) {
for (int i=0;i<10;i++) g[i][0]=0;

for (int t=m;t>0;t--) {
for (int o=0;o<10;o++)
g[o][t]=g[o][t-1];
}
}
}
}

public void efface(int[][] g) {

for (int m=0;m<4;m++) if (piecec[position][m]!=0) g[x+m][y] = 0;
for (int m=0;m<4;m++) if (piecec[position][m+4]!=0) g[x+m][y+1] = 0;
for (int m=0;m<4;m++) if (piecec[position][m+8]!=0) g[x+m][y+2] = 0;
for (int m=0;m<4;m++) if (piecec[position][m+12]!=0) g[x+m][y+3] = 0;

}

public void teste_perdu(int[][] g)
{

for (int m=0;m<16;m++) {
// La case de la pièce est-elle remplie ?
if (piecec[position][m] != 0) {

x1 = m % 4; // colonne de la pièce
y1 = m / 4; // Ligne de la pièce

if (g[x+x1][y+y1] != 0) {

for (int i=0;i<10;i++) {
for (int j=0;j<20;j++) {
g[i][j]=1;
}
}
}
}

}


}




public void descend(int[][] g)
{

efface(g);

y++;

if (bloque(g)) {
y --;
affiche_piece(g);
verifie_ligne(g);
y = 0;
x = 3;
cree_piece();
teste_perdu(g);
} else affiche_piece(g);

}
}

c'est pour linux (freeBSD)???

import java.util.Random;

public class MasterMindJeu
{

public static String genererSequence(int taille)
{
String boules="NBRVbJ";
char[] tmp=boules.toCharArray();
String Resultat="";
int k=0,l=0;
Random alea=new Random();
char sauv='\0';

for(int i=1;i<=taille;i++)
{
for(int j=0;j<50;j++);
{k=alea.nextInt(60)/10;
l=alea.nextInt(60)/10;

sauv=tmp[k];
tmp[k]=tmp[l];
tmp[l]=sauv;}


Resultat+= String.valueOf(tmp[k]);
}

return Resultat;}


public static int nb_place_exactes(String Solution,String proposition)
{
int Resultat=0;
for(int i=0;i<proposition.length();i++)
if(proposition.charAt(i)==Solution.charAt(i)) Resultat++;
return Resultat;
}

public static int nb_place_fausses(String Solution,String proposition)
{
String tmp_prop=proposition;
String tmp_sol=Solution;
int Resultat=0;

for(int i=0;i<tmp_sol.length();i++)
{
if( tmp_sol.charAt(i) == tmp_prop.charAt(i) )
{ tmp_prop = remplacerChar(tmp_prop,i);
tmp_sol = remplacerChar(tmp_sol,i); }
}

tmp_prop = supprimerEspaces(tmp_prop);
tmp_sol = supprimerEspaces(tmp_sol);

int index=0;


for(int i=0;i<tmp_prop.length();i++)
{
index=tmp_sol.indexOf(String.valueOf(tmp_prop.charAt(i)) );

if(index!=-1)
{Resultat++;
tmp_sol = supprimerChar(tmp_sol,index);
}
}
return Resultat;
}

public static String supprimerEspaces(String ch)
{String res="";
for(int i=0;i<ch.length();i++)
if(ch.charAt(i) != ' ') res+=ch.charAt(i);
return res;
}

public static String supprimerChar(String ch,int index)
{String res="";
for(int i=0;i<ch.length();i++)
if(i != index) res+=ch.charAt(i);
return res;
}

public static String remplacerChar(String ch,int index)
{String res="";
for(int i=0;i<ch.length();i++)
if(i != index) res+=ch.charAt(i);
else res+=' ';

return res;
}
}

c'est pour linux??(freeBSD)??

// Importation de classe permettant de lire notamment la méthode Random

import java.util.*;
import java.io.*;

//Le jeu du Pendu tout simplement.

class Pendu{

public static int NB_ERREURS_MAX=10; //Le nombre d'erreur maximale toélérées

public static void main (String args[]){


int i; //Une variable de boucle

String tabMots[] = {"ablation","hypocrisie","interminable","revolution","erudit","feudiste","accueil","explosion","reliure","niais","petit","piquet","blond","punk"};//Tableau contenant tous les mots a trouver.

Random rand=new Random(); //Déclaration de l'objet rand, qui servira a utiliser des nombre aléatoire.

int nbAleatoire=rand.nextInt(tabMots.length); //Cette variable contient un nombre compris entre 0 et la valeur de la taille du tableau des mots a chercher.

String motADeviner=tabMots[nbAleatoire]; //On insère dans la variable motAdeviner le mots qui a été tiré au hasard

int longueurMotAChercher=motADeviner.length(); //On stock dans cette variable la longueur du mot a Deviner.

char tabMotAChercher[]; //On créer un tableau de caractère de même taille que la longueur du mot a chercher

tabMotAChercher=new char [longueurMotAChercher];

char lettreSaisie; //Servira pour la saisi de la lettre

boolean motTrouve=false; //Nous permettra de savoir si le mot est trouve ou pas.

int nbLettresBonnes=0; //Le nombre de bonnes lettres trouvés.

boolean bonneLettre=false; //Nous permettra de savoir si l'utilisateur a entrée une lettre qui se trouve dans le mot ou non?

int erreur=0; //Le nombre d'erreur.

boolean identique=false; //Nous permettra de savoir si l'utilisateur a saisi une lettre identique, qui est déjà afficher a l'écran dans le mot.

String continuer=""; //Afin de faire des pauses dans le programme

int k=0;//Permettra de décaler les cases du tableau de lettres fausse de 1 a chaque erreur.

boolean difference;//Nous permettra de juger si la lettre que l'utilisateur a saisi est différente ou non du mot.

boolean identique2=false; //Nous permettra de savoir si l'utilisateur a saisi une lettre identique, qui n'est pas contenu dans le mot mais qui a été déjà saisie par l'utilisateur.

char verifSaisie[];//Ce tableau contiendra toutes les lettre fausses saisie par l'utilisateur, sa taille est égal au nombre d'erreur.

verifSaisie=new char [NB_ERREURS_MAX];

//ENTETE

System.out.println("*********************************");
System.out.println("*Bienvenue dans le jeu du pendu!*");
System.out.println("*********************************");
System.out.println("");
//FIN ENTETE



//On insère les différents lettres du mots a l'aide de cette boucle

System.out.print("Voici le mot a trouver: ");


for (i=0;i<tabMotAChercher.length;i++){

if (i==0){ //On insére la première lettre du mot dans la case 0

tabMotAChercher[i]=motADeviner.charAt(i);
}

else if (i==tabMotAChercher.length-1){ //On insère la dernière lettres du mot dans la dernière case

tabMotAChercher[i]=motADeviner.charAt(i);


}
else{

tabMotAChercher[i]='-'; //Pour le reste entre on insère des tirets
}

System.out.print(tabMotAChercher[i]); //Affichage des caractères.
}



System.out.println("");
System.out.println("");
System.out.println("-----------------------------------");
System.out.println("");

do{

nbLettresBonnes=0; //Pour l'instant aucune lettre est bonnes.

bonneLettre=false; //Idem.





do{ //Tant que l'utilisateur a saisi des lettres qu'il a déjà saisi auparavant on execute les instruction ci dessous.


if ((identique!=false) || (identique2!=false)){

System.out.println("");
System.out.println("-------------------------------------");
continuer=Console.readLine("ERREUR:Cette lettre a deja ete saisie dans le mot (Appuez sur entree pour continuer)");
System.out.println("-------------------------------------");
System.out.println("");
System.out.print("RAPPEL: le mot a chercher est: ");


for (i=0;i<tabMotAChercher.length;i++){ //On réaffiche le mot a chercher en cas de saisie de lettre déjà saisie.

System.out.print(tabMotAChercher[i]);


}

System.out.println("");
System.out.println("");

}

lettreSaisie=Console.readLine("Quelle lettre desirez vous entrer? ").toLowerCase().charAt(0); //On demande a l'utilisateur de saisir une lettre, on converti cette lettre en minuscule grace a toLowerCase afin d'éviter tout ambiguité

difference=true;

identique=false;
identique2=false;

for (i=0;i<NB_ERREURS_MAX;i++){ //Cette boucle parcours le tableau des lettres érronés, si la lettre saisie par l'utilisateur est déjà contenu dans le tableau alors on considère cette lettre saisie a été saisie auparavant.

if (verifSaisie[i]==lettreSaisie){

identique2=true;
}
}



for (i=1;i<tabMotAChercher.length-1;i++){//Si l'utilisateur a saisie une lettre qui est contenu dans le mot ou si la lettre saisie se trouve dans le tableau des lettres fausses déjà saisie, alors difference devient faux. L'utilisateur a donc juste.

if ((lettreSaisie==motADeviner.charAt(i)) || (identique2==true)){

difference=false;

}
}



if (difference==true){ //Si difference est vrai cela signifie que l'utilisateur s'est trompé on met alors la lettre fausse dans le tabmeau des lettre fausse VerifSaisie.


verifSaisie[k]=lettreSaisie;

k=k+1;

}


for (i=1;i<tabMotAChercher.length-1;i++){//On regarde si la lettre saisie par l'utilisateur n'est pas déjà visible a l'écran.

if (lettreSaisie==tabMotAChercher[i]){

identique=true;
}

}


}

while((identique!=false) || (identique2!=false));


System.out.println("");


//On utilise cette boucle pour vérifier si la lettre saisie correspond bien avec une des lettre dans le mot.

for (i=1;i<tabMotAChercher.length-1;i++){


if (lettreSaisie==motADeviner.charAt(i)){


tabMotAChercher[i]=lettreSaisie;//S'il ya correspondance alors on remplace le tirer par la lettre.

bonneLettre=true;//Cela est donc une bonne lettre
}


}

if (bonneLettre!=true){ //Si l'utilisateur s'est trompé alors on lui ajoute une erreur

erreur=erreur+1;

continuer=Console.readLine("Aucune lettre ne correspond a votre saisie il vous reste : "+(NB_ERREURS_MAX-erreur)+" Chances! (Appuyez sur entree pour continuer)");
System.out.println("");
}


if (erreur!=NB_ERREURS_MAX){


for (i=1;i<tabMotAChercher.length-1;i++){



if (tabMotAChercher[i]==motADeviner.charAt(i)){ //On comptabilise le nombre de bonnes lettre trouvé.

nbLettresBonnes=nbLettresBonnes+1;


}

if (nbLettresBonnes==motADeviner.length()-2){ //Si le nombre de bonnes lettres correspond au nombre de tirets dans le mots alors MotTrouve prends vrai l'utilisateur a gagner.

motTrouve=true;

System.out.println("Vous avez trouvez le mot feliciations!");
System.out.println("");
System.out.println("Le mot etait: "+motADeviner);


}

}



if (motTrouve!=true){


System.out.println("Vous avez trouve en tout "+nbLettresBonnes+" lettres."); //Si le mot n'est pas trouvé alors on affiche le nombre de lettre trouvé en tout
System.out.println("");
System.out.print("Maintenant le mot devient: ");

for (i=0;i<tabMotAChercher.length;i++){

System.out.print(tabMotAChercher[i]); //On affiche le mot après que l'utilisateur est trouver une des lettres


}

System.out.println("");
System.out.println("");

}
System.out.println("-----------------------------------");
}
}

while ((motTrouve==false) && (erreur!=NB_ERREURS_MAX)) ; // On execute les blocs d'instruction du dessus tant que le joueur n'a pas perdu ou tant que le mot a trouver n'est pas trouvé.

if (erreur==NB_ERREURS_MAX){ //Quand on atteint le nombre d'erreur max le joueur perds...
System.out.println("-----------------------------------");
System.out.println("Fin de partie vous avez perdu!");
System.out.println("");
System.out.println("Le mot etait: "+motADeviner);

}
}
}

C'est pour linux ce que j'ai trouver?FREEBSD??
Je suis perdu aidez moi merci