Voila voici le code source d'un jeu en JAVA, seulement il n'y a pas de main.
pourriez vous me dire se qu'il faut mettre dans le main pour qu'il fonctionne, ou s'il manque encore quelques chose.
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);
}
}