Dechiffrage programme jeu de la vie java

Le programme est le suivant

import java.awt.*;
import java.applet.*;

public class GameOfLife2 extends Applet implements Runnable
{
private CellSpace cellSpace;
private Thread gameThread = null;
private int genTime;
private final String clear = "Clear"; // pour effacer
private final String exploder2 = "Exploder"; // creation de figure
private final String slow = "Slow"; // vitesse lente
private final String fast = "Fast"; // vitesse rapide
private final String hyper = "Hyper"; // vitesse hyper rapide
private final String nextLabel = "Next"; // mode manuel
private final String startLabel = "Start"; // pour demarrer en mode automatique
private final String stopLabel = "Stop"; // pour arreter le mode automatique
private Label genLabel;
private Button startstopButton;

public void init()
{
int cellSize; // taille des cellule
int cellCols; // cellule des colonnes
int cellRows; // cellule des lignes
String param;

// set background
setBackground( new Color( 0x099999 ) );

// read parameters from HTML
param = getParameter("cellsize");
if ( param == null) {
cellSize = 25;
} else
cellSize = Integer.valueOf( param ).intValue();

param = getParameter("cellcols");
if ( param == null ) {
cellCols = 25;
} else
cellCols = Integer.valueOf( param ).intValue();

param = getParameter("cellrows");
if ( param == null ) {
cellRows = 25;
} else
cellRows = Integer.valueOf( param ).intValue();

param = getParameter("gentime");
if ( param == null ) {
genTime = 1000; // intervalle de tps entre chaque etape (2s)
} else
genTime = Integer.valueOf( param ).intValue();

// create components and add them to container
cellSpace = new CellSpace( cellSize, cellCols, cellRows );

Choice c = new Choice();
c.addItem( clear );
c.addItem( exploder2 );

Choice speed = new Choice();
speed.addItem( slow );
speed.addItem( fast );
speed.addItem( hyper );

genLabel = new Label( "Generations: 0 " ); // pr creer l etiquette generation (etape)

startstopButton = new Button( startLabel ); // pr creer le bouton start et stop

Panel controls = new Panel(); // pr afficher un panneau de control
controls.add( c );
controls.add( new Button( nextLabel )); // pr creer le bouton next pr passer a l etape d apres
controls.add( startstopButton );
controls.add( speed ); // pour afficher et choisir la vitesse
controls.add( genLabel ); // pour afficher les etapes (generations)

setLayout(new BorderLayout()); // pr definir la frontiere
add( "North", controls ); // pr afficher les bouton de control en haut
add( "South", cellSpace );// pr afficher la grille en dessous des boutons de controles
show();// montrer
resize( preferredSize() );// pr afficher avec une taille redimensioné automatiquement
validate();
}

// no start() to prevent starting immediately
public void start2() {
if(gameThread == null) {
gameThread = new Thread(this);
gameThread.start();
}
}

public void stop() { // pr parametrer le bouton stop
if(gameThread != null) {
gameThread.stop();
gameThread = null;
}
}

public void run() {
while (gameThread != null) {
cellSpace.next();
cellSpace.repaint();
showGenerations();
try {
gameThread.sleep( genTime );
} catch (InterruptedException e){}
}
}

public boolean action(Event evt, Object arg) {
if( clear.equals( arg ) ) // clear
{
cellSpace.clear();
cellSpace.repaint();
showGenerations();
return true;
}
else if(exploder2.equals(arg))
{
int shape[] = { 0,0, 0,1, 0,2, 0,3, 0,4, 2,0, 2,4, 4,0, 4,1, 4,2, 4,3, 4,4 };
drawShape( 5, 5, shape );
return true;
}
else if(nextLabel.equals(arg)) // next
{
cellSpace.next();
cellSpace.repaint();
showGenerations();
return true;
}
else if(startLabel.equals(arg)) // start
{
start2();
startstopButton.setLabel( stopLabel );
return true;
}
else if(stopLabel.equals(arg)) // stop
{
stop();
startstopButton.setLabel( startLabel );
return true;
}
else if(slow.equals(arg)) // parametrer la vitesse lente
{
genTime = 500;
return true;
}
else if(fast.equals(arg)) // paramatrer la vitesse rapide
{
genTime = 100;
return true;
}
else if(hyper.equals(arg)) // parametrer la vitesse tres rapide
{
genTime = 0;
return true;
}
return false;
}

public String getAppletInfo()
{
return "Game Of Life v. 1.3\nCopyright 1996-2001 Edwin Martin";
}

// show number of generations
public void showGenerations() {
genLabel.setText( "Generations: "+cellSpace.generations );
}

// draws the shape to canvas
public void drawShape( int shapeWidth, int shapeHeight, int shape[] ) {
if ( !cellSpace.drawShape( shapeWidth, shapeHeight, shape ) )
showStatus( "Shape is too big to fit." );
else {
showStatus( "" );
cellSpace.repaint();
showGenerations();
}
}

}

class CellSpace extends Canvas
{
public int generations;
private int cellSize;
private int cellRows;
private int cellCols;
private boolean cellUnderMouse;
private boolean cells[][];
private int cellsBuffer[][];
private Image offScreenImage = null;
private Graphics offScreenGraphics;

public CellSpace( int cellSize, int cellCols, int cellRows ) {
cells = new boolean[cellCols][cellRows];
cellsBuffer = new int[cellCols][cellRows];
this.cellSize = cellSize;
this.cellCols = cellCols;
this.cellRows = cellRows;
reshape(0, 0, cellSize*cellCols-1, cellSize*cellRows-1);
clear();
}

public synchronized boolean mouseUp(java.awt.Event evt, int x, int y) {
// toggle cell
try {
cells[x/cellSize][y/cellSize] = !cellUnderMouse;
} catch ( java.lang.ArrayIndexOutOfBoundsException e ) {}
repaint();
return true;
}

public synchronized boolean mouseDown(java.awt.Event evt, int x, int y) {
try {
cellUnderMouse = cells[x/cellSize][y/cellSize];
} catch ( java.lang.ArrayIndexOutOfBoundsException e ) {}
return true;
}

public synchronized boolean mouseDrag(java.awt.Event evt, int x, int y) {
// toggle cell
try {
cells[x/cellSize][y/cellSize] = !cellUnderMouse;
} catch ( java.lang.ArrayIndexOutOfBoundsException e ) {}
repaint();
return true;
}

public synchronized void update( Graphics theG )
{
Dimension d = size();
if((offScreenImage == null) ) {
offScreenImage = createImage( d.width, d.height );
offScreenGraphics = offScreenImage.getGraphics();
}
paint(offScreenGraphics);
theG.drawImage( offScreenImage, 0, 0, null );
}

public void paint(Graphics g) {
// draw background (MSIE doesn't do that)
g.setColor( Color.gray );
g.fillRect( 0, 0, cellSize*cellCols-1, cellSize*cellRows-1 );
// draw grid
g.setColor( getBackground() );
for( int x=1; x<cellCols; x++ ) {
g.drawLine( x*cellSize-1, 0, x*cellSize-1, cellSize*cellRows-1 );
}
for( int y=1; y<cellRows; y++ ) {
g.drawLine( 0, y*cellSize-1, cellSize*cellCols-1, y*cellSize-1 );
}
// draw populated cells
g.setColor( Color.yellow );
for( int y=0; y<cellRows; y++ ) {
for( int x=0; x<cellCols; x++ ) {
if ( cells[x][y] ) {
g.fillRect( x*cellSize, y*cellSize, cellSize-1, cellSize-1 );
}
}
}
}

// clears canvas
public synchronized void clear() {
generations = 0;
for( int x=0; x<cellCols; x++ ) {
for( int y=0; y<cellRows; y++ ) {
cells[x][y] = false;
}
}
}

// create next generation of shape
public synchronized void next() {
int x;
int y;

generations++;
// clear the buffer
for( x=0; x<cellCols; x++ ) {
for( y=0; y<cellRows; y++ ) {
cellsBuffer[x][y] = 0;
}
}

// count neighbors of off-edge cells
for( x=1; x<cellCols-1; x++ ) {
for( y=1; y<cellRows-1; y++ ) {
if ( cells[x][y] ) {
cellsBuffer[x-1][y-1]++;
cellsBuffer[x][y-1]++;
cellsBuffer[x+1][y-1]++;
cellsBuffer[x-1][y]++;
cellsBuffer[x+1][y]++;
cellsBuffer[x-1][y+1]++;
cellsBuffer[x][y+1]++;
cellsBuffer[x+1][y+1]++;
}
}
}

// count neighbors of edge cells
x=1; // start at (1,0)
y=0;
int dx=1;
int dy=0;
while( true ) {
if ( cells[x][y] ) {
if ( x > 0 ) {
if ( y > 0 )
cellsBuffer[x-1][y-1]++;
if ( y < cellRows-1 )
cellsBuffer[x-1][y+1]++;
cellsBuffer[x-1][y]++;
}
if ( x < cellCols-1 ) {
if ( y < cellRows-1 )
cellsBuffer[x+1][y+1]++;
if ( y > 0 )
cellsBuffer[x+1][y-1]++;
cellsBuffer[x+1][y]++;
}
if ( y > 0 )
cellsBuffer[x][y-1]++;
if ( y < cellRows-1 )
cellsBuffer[x][y+1]++;
}

// turn clockwise at collision with edge
if ( x==cellCols-1 && y==0 ) {
dx = 0;
dy = 1;
} else if ( x==cellCols-1 && y==cellRows-1 ) {
dx = -1;
dy = 0;
} else if ( x==0 && y==cellRows-1 ) {
dx = 0;
dy = -1;
} else if ( x==0 && y==0 ) {
// all edge cells done
break;
}
x += dx;
y += dy;
}

// here is the life algorithm
// simple, isn't it?
for( x=0; x<cellCols; x++ ) {
for( y=0; y<cellRows; y++ ) {
switch( cellsBuffer[x][y] ) {
case 2:
// no change
break;
case 3:
cells[x][y] = true;
break;
default:
cells[x][y] = false;
break;
}
}
}

}

// draws shape in cells
// returns false if shape doesn't fit
public synchronized boolean drawShape( int shapeWidth, int shapeHeight, int shape[] ) {
int xOffset;
int yOffset;

if ( shapeWidth>cellCols || shapeHeight>cellRows )
return false; // shape doesn't fit on canvas

// center the shape
xOffset = (cellCols-shapeWidth)/2;
yOffset = (cellRows-shapeHeight)/2;
clear();
for ( int i=0; i < shape.length; i+=2 )
cells[xOffset+shape[i]][yOffset+shape[i+1]] = true;
return true;
}

}

En faite c'est très simple, ton programme permet de créer une aventure aléatoire dans une ville que tu simules(de très grande taille apparemment). Dans ton premier package tu as crée des attributs variables ( oups j'ai oublié de te dire que c'était dans la deuxième classe crée) avec ces attributs tu as crée les personnages de ton aventure aléatoire. C'est parti nos courageux aventuriers sont lancés ( leur niveau et capacités sont en attribut 4eme classe en tournant à gauche).