Visualizzazione dei risultati da 1 a 3 su 3
  1. #1
    Utente di HTML.it
    Registrato dal
    Nov 2006
    Messaggi
    44

    [J2ME] aiuto sul gioco del tetris

    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.

  2. #2
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,328

    Moderazione

    Java viene trattato nell'apposito Sub-Forum.

    Ti sposto.


    Ciao.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  3. #3
    Utente di HTML.it
    Registrato dal
    Nov 2006
    Messaggi
    44
    up

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2026 vBulletin Solutions, Inc. All rights reserved.