[J2ME] aiuto sul gioco del tetris

[BeagleKoki]

Salve,
ho bisogno di un aiuto.
Vorrei creare un gioco simile al tetris ma solo con i quadrati dove, appena un quadrato di colore verde si scontra con un altro dello stesso colore, scompaiono entrambi.
Ho iniziato a gestire la grafica e il movimento ma, se muovo il quadrato a destra o a sinistra appena questo tocca il bordo non scende piu(si blocca li).
Avrei dunque bisogno di alcuni aiuti:
- se il quadratino tocca il bordo laterale si blocca e non scende più.
- vorrei gestire tramite il random il colore dei quadrati (ogni volta che ne scende uno nuovo vorrei fargli cambiare colore).
Posto il codice che ho scritto fino ad ora:
codice:

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;

public class Applicazione extends MIDlet {
    private Display display;
    private CanvasTetris canvas;
    
    //costruttore
    public Applicazione() {
        display = Display.getDisplay(this);
        canvas  = new CanvasTetris(this);
    }
    
    protected void startApp() {
        display.setCurrent(canvas);
    }
    
    protected void pauseApp() {
    }
    
    protected void destroyApp( boolean unconditional ) {
    }
    
    // cEsci
    public void exitMIDlet() {
        destroyApp(true);
        notifyDestroyed();
    }
}

//-----------------------------------------------------------------------------------------------------------//
//-----------------------------------------------------------------------------------------------------------//

// classe intesa come "midlet grafico" a parte.
class CanvasTetris extends Canvas implements CommandListener {
    
    private Command cmExit, cPausa;
    private String keyText = "", testo="";
    private Applicazione midlet;
    private int x, y, cx, cy, dMp=24, iTime=50, iTime2=0, score,pz=1;
    private int size, rnd=-1, rnd2=-1;  //size è la dimensione in pixel (larghezza e altezza ) di ogni cella della matrice
    private int mp [][] = new int [12][22];
    private int px [] = new int [4];
    private int py [] = new int [4];
    
    private boolean pausa;
    private Timer tm;
    private TimerTask tt;
    
    
    
    
    
    
    // costruttore
    public CanvasTetris(Applicazione midlet) {
        this.midlet = midlet;    // dentro al canvas "midlet" contiene midlet della classe più esterna.
        cmExit = new Command("Exit",Command.EXIT,0);
        cPausa = new Command("Pausa",Command.OK,0);
        addCommand(cmExit);
        addCommand(cPausa);
        setCommandListener(this);
        
        tm = new Timer();
        
        
        tt = new TimerTT();
        tm.scheduleAtFixedRate(tt,0,200);
       
        score=0;
        
        //COSTRUISCO LE COORDINATE DEL QUADRATO GRIGIO
        px[0]=4;
        py[0]=1;
        px[1]=5;
        py[1]=1;
        px[2]=4;
        py[2]=2;
        px[3]=5;
        py[3]=2;
        pz=1;
        
        
        
        //COSTRIUSCO LE VERIABILI DEL RETTANGOLO VERDE
        px[0]=4;
        py[0]=1;
        px[1]=4;
        py[1]=2;
        px[2]=4;
        py[2]=3;
        px[3]=4;
        py[3]=4;
        pz=2;
        
      


        
      
        //COSTRUISCO UNA CORNICE GIALLA
        for (int c=0;c<12;c++) { //12 E' IL BORDO ORIZZONTALE
            mp[c][0]=-1;
            mp[c][21]=-1;
        }
        for (int r=0;r<21;r++) { //21 E' IL BORDO IN VERTICALE
            mp[0][r]=-1;
            mp[11][r]=-1;
        }
        
        
        
        size=getWidth()/16 ; //SCELGO LA LARGHEZZA DEL PIXEL
        if(getHeight()/22<size){   //SCELGO L'ALTEZZA DEL PIXEL
            size=getHeight()/22; //SE L'ALTEZZA E' PIU PICCOLA DELLA LARGHEZZA DISEGNAMI UN QUADRATINO
        }
    }
    private class TimerTT extends TimerTask {
        public final void run() {
            boolean ok=false;
        
            for (int i=0;i<4;i++){
                
                ok=false;
                if (mp[px[i]][py[i]+1]==0)     // CONTROLLA SE C'E' UNO SPAZIO VUOTO SOTTO
                    ok=true;
                
                
                else{
                    for (int j=0;j<4;j++){
                        if (py[j]==py[i]+1 && px[j]==px[i])    {
                            ok=true;
                        }
                    }
                }
                
                //CONTROLLA CHE NON CI SIA LA MIA CORNICE GIALLA
                // SE C'E' LA CORNICE IL QUADRATINO SI FERMA
                
                if (mp[px[i]+1][py[i]]==-1)      //Gestisco la parte di destra
                    ok=false;                    // il quadratino non va oltre il riquadro
                
                
                
                if(mp[px[i]-1][py[i]]==-1)      //Gestisco la parte di sinistra
                    ok=false;                   //  il quadratino non va oltre il riquadro
                
                
                
                if (!ok)
                    i=5;
            }
            if (!ok)      {
                px[0]=4;
                py[0]=1;
                px[1]=5;
                py[1]=1;
                px[2]=4;
                py[2]=2;
                px[3]=5;
                py[3]=2;
                pz=1;
                for (int k=0;k<4;k++)
                    mp[px[k]][py[k]]=pz;
                return;
            }
            
            
            
            
            pz=0;
            for (int k=0;k<4;k++)
                mp[px[k]][py[k]]=pz;
            
            px[0]=px[0];
            py[0]=py[0]+1;
            px[1]=px[1];
            py[1]=py[1]+1;
            px[2]=px[2];
            py[2]=py[2]+1;
            px[3]=px[3];
            py[3]=py[3]+1;
            pz=1;
            for (int k=0;k<4;k++)
                mp[px[k]][py[k]]=pz;
            
            
            repaint();
            
        }
}
    // CREAZIONE DEL METODO PAINT
    
    protected void paint(Graphics g) {
        g.setColor(0,0,132);
        g.fillRect(0,0,getWidth(),getHeight());
        
//        g.setColor(0,0,0);
//        g.fillRect(10,10,getWidth()-80,getHeight()-60);
        
//        // 2  righe gialle
        g.setColor(255,255,0);
        g.drawString("Punteggio: " + score ,getWidth()-80,getHeight()-260,0);
//        g.drawString("Score: " + score ,getWidth()-150,getWidth()+18,0);
        for(int xx=0; xx<12; xx++) {
            for(int yy=0; yy<22; yy++) {
                switch(mp[xx][yy]) {
                    case 1:   // LA MIA POSIZIONE
                    {
                        g.setColor(255,255,0);
                        g.fillRect(xx*size,yy*size,size,size);
                        break;
                    }
                    case -1:
                    {
                        g.setColor(154,53,255);
                        g.fillRect(xx*size,yy*size,size,size);
                        break;
                    }
                    case 2:   // LA MIA POSIZIONE
                    {
                        g.setColor(24,201,82);
                        g.fillRect(xx*size,yy*size,size,size);
                        break;
                    }
                }
            }
        }
    }
    public void commandAction(Command c, Displayable s) {
        if (c == cmExit) {
            midlet.exitMIDlet();
        }
        if(c == cPausa) {
            repaint();
            pausa = !pausa;
        }
    }
    protected void keyPressed(int keyCode) {
        keyText=getKeyName(keyCode);
//        if(keyText.equals("DOWN")){
//
//            pz=0;
//            for (int k=0;k<4;k++)
//                mp[px[k]][py[k]]=pz;
//
//            px[0]=px[0];
//            py[0]=py[0]+1;
//            px[1]=px[1];
//            py[1]=py[1]+1;
//            px[2]=px[2];
//            py[2]=py[2]+1;
//            px[3]=px[3];
//            py[3]=py[3]+1;
//            pz=1;
//            for (int k=0;k<4;k++)
//                mp[px[k]][py[k]]=pz;
//
//
//            repaint();
//
//        }
        if(keyText.equals("LEFT")){
            
            pz=0;
            for (int k=0;k<4;k++)
                mp[px[k]][py[k]]=pz;
            
            px[0]=px[0]-1;
            py[0]=py[0];
            px[1]=px[1]-1;
            py[1]=py[1];
            px[2]=px[2]-1;
            py[2]=py[2];
            px[3]=px[3]-1;
            py[3]=py[3];
            pz=1;
            for (int k=0;k<4;k++)
                mp[px[k]][py[k]]=pz;
            
            
            repaint();
            
        }
        if(keyText.equals("RIGHT")){
            
            pz=0;
            for (int k=0;k<4;k++)
                mp[px[k]][py[k]]=pz;
            
            px[0]=px[0]+1;
            py[0]=py[0];
            px[1]=px[1]+1;
            py[1]=py[1];
            px[2]=px[2]+1;
            py[2]=py[2];
            px[3]=px[3]+1;
            py[3]=py[3];
            pz=1;
            for (int k=0;k<4;k++)
                mp[px[k]][py[k]]=pz;
            
            
            repaint();
            
        }
        if(pausa == false) {
//            muovi();
        }
        // caso pausa
        else {
            
            
            
        }
    }
    
}

Sto diventando matto perchè non riesco a fare queste due cose.
Aiutatemi!!
Grazie.

[BeagleKoki]

up