[JAVA] Gestione degli eventi

[3nigma666]

Salve...mi sto cimentando da un poco nel mondo di java,e per prima cosa ho deciso di provare a creare il gioco snake.
il codice non è completo,ma credo di essere a buon punto.
Il programma è cosi strutturato. Una superclasse Nodo e una sottoclasse Snake. Nodo non è altro ke l'elemento piu piccolo di cui è composto l'oggetto snake. Infatti inizialmente il serpente è costituito da 5 nodi.ogni nodo contiene le coordinate e un puntatore al nodo successivo.
Dopodi ke ho creato la classe Ball ke rappresenta le palline ke il serpende deve creare.la classe al suo interno contiene le coordinate della pallina ,ke genera automaticamente tramite la classe RandomGenerator.
ho successivamente costruito la classe Mappa che non è altro ke un enorme rettangolo rappresentante la mappa all'interno del quale si muove il serpente.
Attraverso la classe Panels creo il pannello ove all'interno disegno gli oggetti snake ,ball e mappa.e Infine la classe DrawFrame crea il frame e all'interno ci aggiunge il pannello con i suoi relativi oggetti disegnati.

questo è in linea di massima il funzionamento e qello ke fino ad ora ho implementato.vi posto pero il codice perke ho un problema,non riesco a gestire gli eventi della tastiera.ovverosia per muovere il serpente intendevo fare un ciclo while dove all'interno viene incrementata la posizione del serpente nella direzione scelta dall'utente,e il ciclo si ferma solo nel caso in cuinn viene premuto il tasto di movimento (esempio freccia sx)
il problmea è ke quando ho una classe tipo:

private class KeyHandler implements KeyListener
{
..
}

il compilatore mi da errore dicendo ke la classe è abstract. allora aggiugno l atributo abstract ma cosi quando devo richiamare il costruttore in questa maniera :

KeyHandler listener = new KeyHandler();
addKeyListener(listener);
mi da errore dicendomi ke la classe è abstract e non posso qindi inizializzare l'oggetto con il costruttore.

ke farE?????????? v prego help !!!

vi posto il codice:

////////////////////////// NODO.java /////////////////////////////////

public class Nodo{
    private int height;//ALtezza
	private int width;//larghezza
	private int leftX;//Coordinata X angolo sx superiore
	private int topY;//Coordinata angolo SX superiore
	private Nodo succ; // Puntatore a Nodo successivo

	public Nodo(int width,int height,int leftX,int topY)
	{
	    this.leftX  = leftX;
	    this.topY   = topY;
	    this.height = height;
		this.width  = width;
		this.succ   = null; //inizializzo a null il puntatore all'oggetto successivo
	}//End void Nodo()

	//------------------------------
	// Name : C_Height
	// Desc : cambia il valore della variabile height
	// ToDo : Nulla ;)
	//------------------------------------------------
	
	   public void C_height(int height){ 
       this.height = height;
    }
    
    //------------------------------
	// Name : C_width
	// Desc : cambia il valore della variabile width
	// ToDo : Nulla ;)
	//------------------------------------------------
    public void C_width(int width){
        this.width = width;
    }
    
    //------------------------------
	// Name : C_left
	// Desc : cambia il valore della variabile leftX
	// ToDo : Nulla ;)
	//------------------------------------------------
    
    public void C_leftX(int leftX){
        this.leftX = leftX;
    }
    
    //------------------------------
	// Name : C_topY
	// Desc : cambia il valore della variabile topY
	// ToDo : Nulla ;)
	//------------------------------------------------
    
    public void C_topY(int topY){
        this.topY = topY;
    }

    //------------------------------
	// Name : C_succ
	// Desc : Cambia l'indirizzo di memoria al quale punta succ
	// ToDo : Nulla ;)
	//------------------------------------------------
    
    public void C_succ(Nodo succ){
        this.succ = succ;
    }
    
//FUNZIONI KE RITORNATO I VALORI DELLE VARIABILI PRIVATE

    public int height(){
        return height;
    }
    
    public int width(){
        return width;
    }
    
    public int leftX(){
        return leftX;
    }
    
    public int topY(){
        return topY;
    }
     
    public Nodo succ(){
        return succ;
    }
    
}//End class Nodo

////////////////////////////////// SNAKE.JAVA //////////////////////////////////

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Snake extends Nodo
{
  private Nodo testa; //inizializzo un oggetto testa di tipo Nodo
  private Nodo temp;
  
  public Snake(int width,int height,int leftX,int topY)
    {
     super(width,height,leftX,topY); //richiamo il costruttore della superclasse
     Nodo nodo = new Nodo(width,height,leftX,topY); //Creo un nuovo nodo
     nodo.C_leftX(leftX);
     nodo.C_topY(topY);
     testa = nodo; //assegno a testa lo stesso reference di nodo cosi entrambi puntano allo stesso indiz. d memoria
     
    }     
//-------------------------------------------------
//  Idea della struttura del serpente
//  |------------ |    | ----------- |
//  |testa | succ | -> | nodo | succ | -> null
//  |-------------|    | ----------- |
//
//-------------------------------------------------    

//------------------------------------------
// Name : Create_Snake
// Desc : Crea un serpente iniziale di 5 elementi
// ToDo : Nulla
//--------------------------------------------------

public void Create_Snake(int max,Nodo temp,int leftX,int topY){
    for (int i = 1;i<=max;i++){
    temp.C_leftX(temp.width()*i);//imposto il nodo successivo adiacente al nodo precedente
    temp.C_succ(new Nodo(10,10,leftX,topY));//assegno al puntatore del nodo successivo un nuovo Nodo
    temp = temp.succ();//faccio diventare temp il nuovo nodo
    }
}//End Create_Snake   
//-----------------------------------------
// Name : moveto
// Desc : Funzione ke muove il serpente tramite lo switch sull variabile direction
// Legenda : direction : 1 = SU
//                       2 = GIU
//                       3 = SX
//                       4 = DX
// ToDo : terminare di implementare il movimento
//----------------------------------------------------------------


public Nodo moveto(int direction,Snake snake)
{
  temp = snake.testa;
  Nodo temp1 = temp.succ();
  switch (direction)
  {
      case 1 :
               if ((temp. topY() - 10)  != temp1.topY()) //se il NON serpente si sviluppa verso l'alto
               {
                   snake.testa = new Nodo(10,10,temp.leftX(),temp.topY() - 10); //Alla testa assegno un nuovo nodo
                   snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa  
                   temp = snake.testa;//assegno a temp la nuova testa
                   temp1 = temp.succ();//assegno a temp1 il successivo a temp
                   while (temp1.succ() != null)
                   {
                       temp = temp.succ();
                       temp1 = temp1.succ();
                       if (temp1.succ() == null)
                        temp.C_succ(null);
                   }  
                };break;
       case 2 :
              if ((temp.topY() + 10)  != temp1.topY()) //se il NON serpente si sviluppa verso l'alto
               {
                   snake.testa = new Nodo(10,10,temp.leftX(),temp.topY()+ 10); //Alla testa assegno un nuovo nodo
                   snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa  
                   temp = snake.testa;//assegno a temp la nuova testa
                   temp1 = temp.succ();//assegno a temp1 il successivo a temp
                   while (temp1.succ() != null)
                   {
                       temp = temp.succ();
                       temp1 = temp1.succ();
                       if (temp1.succ() == null)
                        temp.C_succ(null);
                   }  
                };break;
       case 3 : 
                if ((temp.leftX() - 10)  != temp1.leftX()) //se il NON serpente si sviluppa verso l'alto
               {
                   snake.testa = new Nodo(10,10,temp.leftX() - 10,temp.topY()); //Alla testa assegno un nuovo nodo
                   snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa  
                   temp = snake.testa;//assegno a temp la nuova testa
                   temp1 = temp.succ();//assegno a temp1 il successivo a temp
                   while (temp1.succ() != null)
                   {
                       temp = temp.succ();
                       temp1 = temp1.succ();
                       if (temp1.succ() == null)
                        temp.C_succ(null);
                   }  
                };break;     
       case 4 : 
                if ((temp.leftX() + 10)  != temp1.leftX()) //se il NON serpente si sviluppa verso l'alto
               {
                   snake.testa = new Nodo(10,10,temp.leftX() + 10,temp.topY()); //Alla testa assegno un nuovo nodo
                   snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa  
                   temp = snake.testa;//assegno a temp la nuova testa
                   temp1 = temp.succ();//assegno a temp1 il successivo a temp
                   while (temp1.succ() != null)
                   {
                       temp = temp.succ();
                       temp1 = temp1.succ();
                       if (temp1.succ() == null)
                        temp.C_succ(null);
                   }  
                };break;            
   }  //End switch
   return snake.testa;
}   
public Nodo testa()
{
    return testa;
}

}


///////////////////////// BALL.java /////////////////////////////////

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;

public class Ball
{
  private long leftX;
  private long topY;
  private long width;
  private long height;
  RandomGenerator r = new RandomGenerator(123456789);
  
  public Ball(int width,int height)
  {
     
      this.width = width;
      this.height = height;
      leftX = 0;
      topY = 0;
   }
   //--------------------------------------------------------
   // Name : Gen_Coo
   // Desc : Genera delle Coordinate Random per le palline
   //        Inoltre ad ogni generazione viene controllato ke le coordinate non corrispondano con un nodo
   //        dello snake e ke le coordinate non siano fuori dall'area della Mappa
   // ToDo : Nulla ;)
   // Vers : 1.0
   // Bugs : Per Ora nulla :D
   //-------------------------------------------------------------------------------------------
   public void Gen_Coo(Nodo nodo,int max,Mappa mappa,int screenWidth,int screenHeight)
   {
       Nodo temp = nodo; // Nodo temp necessario per scorrere la lista dei nodi del serpente
       boolean Coo_ok = true; //inzializzo a true la variabile
       leftX = Math.round(r.get() * screenHeight);//Genero le coordinate con la funzione random
       topY  = Math.round(r.get() * screenWidth );
       while (temp.succ() != null) //fino a quando non arrivo alla fine della lista cicla
           {
               do
               {     // se le coordinate corrispondono a quelle del serpente o se sono fuori dalla mappa
                if (((temp.leftX() == leftX) && (temp.topY() == topY)) || leftX <= mappa.leftX() || leftX >= (mappa.leftX() + mappa.width()) || topY <= mappa.topY() || topY >= (mappa.topY() + mappa.height()) )
                {
                    Coo_ok = false; // assegna condizione di falsita
                    leftX = Math.round(r.get() * screenHeight); // rogenera le coordinate
                    topY  = Math.round(r.get() * screenWidth); //rigenera le coordinate
                }//End if
                else//altrimenti dai il nulla hosta per uscire dal ciclo
                    Coo_ok = true;
             } while (Coo_ok != true /*|| i <= 50*/); //continua fino a quando le coordinate non sono corrette
             temp = temp.succ();//Passo all'elemento successivo del serpente
            }
     }//End Gen_Coo
    
    
    public double height(){
        return height;
    }
    
    public double width(){
        return width;
    }
    
    public double leftX(){
        return leftX;
    }
    
    public double topY(){
        return topY;
    }     
     
}   



/////////////////////////// RANDOMGENERATOR.java //////////////////

//
// Classe che genera numeri casuali,
// migliore del random di sistema
//
public class RandomGenerator {
   //
   // get(): restituisce un numero compreso tra 0 e 1
   //
   public double get()
   {
      //
      // Costanti
      //
      final int a = 16087;
      final int m = 2147483647;
      final int q = 127773;
      final int r = 2836;

      //
      // Variabili
      //
      double lo, hi, test;

      hi = Math.ceil(seed / q);
      lo = seed - q * hi;
      test = a * lo - r * hi;
      if (test < 0.0) {
         seed = test + m;
      } else {
         seed = test;
      } /* endif */
      return seed / m;
   }

   //
   // getSeed(): restituisce il valore corrente del seme
   //
   public double getSeed()
   {
      return seed;
   }

   //
   // setSeed(s): imposta il valore del seme a s
   //
   public void setSeed(double s)
   {
      seed = s;
   }

   //
   // costruttore della classe, genera un'istanza di RandomGenerator,
   // fissando il seme iniziale a s.
   //
   public RandomGenerator(double s)
   {
      seed = s;
   }

   private double seed;
}

/////////////////////////// MAPPA.java //////////////////////////////////

public class Mappa
{
    private int height;//ALtezza
	private int width;//larghezza
	private int leftX;//Coordinata X angolo sx superiore
	private int topY;
	public Mappa(int leftX,int topY,int width,int height)
	{
	    this.leftX = leftX;
	    this.topY = topY;
	    this.width = width;
	    this.height = height;
	}
	
	public int leftX()
	{
		// put your code here
		return leftX;
	}
	public int topY()
	{
		// put your code here
		return topY;
	}
	public int width()
	{
		// put your code here
		return width;
	}
	public int height()
	{
		// put your code here
		return height;
	}
	
	
	
}
///////////////////////////// PANEL.java ////////////////////////////////////

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;

public class Panels extends JPanel
{
  Robot robot;
   public Panels()
   {
      /* try {
	           robot = new Robot();
	       } catch (AWTException e) {
	           System.out.println("Problem creating Robot.  FAIL.");
	           throw new RuntimeException("Problem creating Robot.  FAIL.");
	       }  */  
   }
  
	public void paintComponent(Graphics g)
	{ 
	    super.paintComponent(g);
	//-----------------INIZIALIZZAZIONE AREA DI GIOCO-----------------
	    Toolkit kit = Toolkit.getDefaultToolkit();
        Dimension screenSize = kit.getScreenSize();
        int screenHeight = screenSize.height;
        int screenWidth = screenSize.width;
	    Graphics2D g2 = (Graphics2D) g;
	    g2.drawString("SNAKE Beta Vers. 0.01 Valerio Bignardi",10,10);
	    //--------CREO LA MAPPA-----------
	    Mappa mappa = new Mappa((screenWidth / 8) - 55,(screenHeight / 8) -50,screenWidth / 3,screenHeight / 3);
	    Rectangle2D map = new Rectangle.Double(mappa.leftX(),mappa.topY(),mappa.width(),mappa.height());
	    g2.draw(map);
	    //--------CREO IL SERPENTE-------------
	    Snake snake = new Snake(10,10,(mappa.width() + 55) / 2,(mappa.height() + 50) / 2);
	    snake.Create_Snake(5,snake.testa(),(mappa.width() + 55) / 2,(mappa.height() + 50) / 2);
	    Nodo temp = snake.testa();
	    while (temp.succ() != null)
	    {
	        Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
	        g2.draw(rect);
	        temp = temp.succ();
	    }
	    //----------Disegno Le palline------
	    Ball ball = new Ball(10,10);
	    ball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3);
	    Rectangle2D bal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height());
		g2.setPaint(Color.RED);
		g2.fill(bal);
		g2.draw(bal);
 //-------------------INIZIO IL GIOCO-------------------
 
		
		
		
	}
	
/*	private abstract class keyHandler implements KeyListener
	{
	    public void keyPressed (KeyEvent event)
	    {
	        int keyCode = event.getKeyCode();
	        if (keyCode == KeyEvent.VK_RIGHT)
	        System.out.println("hai premuto il tasto right");
	    }
	} */  
}


/////////////////////////////// DRAWFRAME.java /////////////////////////

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;

public class DrawFrame
{
	public static void main (String[] args)
	{
	    SnakeFrame frame = new SnakeFrame();
	    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	    frame.setVisible(true);
    }    
}


class SnakeFrame extends JFrame
{
  public SnakeFrame()
  {
      Toolkit kit = Toolkit.getDefaultToolkit();
      Dimension screenSize = kit.getScreenSize();
      int screenHeight = screenSize.height;
      int screenWidth = screenSize.width;
      setSize(screenWidth / 2,screenHeight / 2);
      setLocation (screenWidth / 4, screenHeight / 4);
      setTitle("Snake Beta Vers. 0.1 By Valerio Bignardi");
      Panels panel = new Panels();
      add(panel);
    }    
}

//////////////////////////////////////////////////////////////////////////////////

Ecco questo il codice. nella classe Panels c'è l inghippo sopracitato. Il codice per il resto è corretto (a parte un piccolo particolare con il serpente:quando viene creato,posso dare qualsiasi valore alla coordinata ,ma tanto la posizione NON si sa perke rimane sempre la stessa. Ci sara qualke piccolo errore di codice ke dovrò rivedere. Piu ke altro mi preme sapere come gestire gli eventi se qualcuno puo aiutarmi.
Grazie mille

3NiGm@666

[Guille]

I Listener devono essere registrati sugli oggetti in cui succedono gli eventi che devono essere "ascoltati".

Prova ad integrare nella tua classe Panels questo codice:

public class Panels extends JPanel implements KeyListener { 

    public Panels() {
        addKeyListener(this);  // registrazione del listener
        // ...  
    }

    // .... 
    /* implementazione del listener */
    public void keyPressed (KeyEvent event)  { 
        int keyCode = event.getKeyCode(); 
        if (keyCode == KeyEvent.VK_RIGHT) 
             System.out.println("hai premuto il tasto right"); 
    } 
    public void keyTyped(KeyEvent e) { }
    public void keyReleased(KeyEvent e) { }

}

PS:Java naming conventions

[3nigma666]

inanzittutto grazie mille!!!sei stato gentilissimo. o ho implementato in questo modo

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;

public class Panels extends JPanel implements KeyListener
{
  public int keyCode;
   public Panels()
   {
       addKeyListener(this);  // registrazione del listener
        // ...  
      
   }
    /* implementazione del listener */
    public void keyPressed (KeyEvent event)  { 
        keyCode = event.getKeyCode(); 
        if (keyCode == KeyEvent.VK_RIGHT) 
             System.out.println("hai premuto il tasto right"); 
    } 
    public void keyTyped(KeyEvent e) { }
    public void keyReleased(KeyEvent e) { }

	public void paintComponent(Graphics g)
	{ 
	    super.paintComponent(g);
	//-----------------INIZIALIZZAZIONE AREA DI GIOCO-----------------
	    Toolkit kit = Toolkit.getDefaultToolkit();
        Dimension screenSize = kit.getScreenSize();
        int screenHeight = screenSize.height;
        int screenWidth = screenSize.width;
	    Graphics2D g2 = (Graphics2D) g;
	    g2.drawString("SNAKE Beta Vers. 0.01 Valerio Bignardi",10,10);
	    //--------CREO LA MAPPA-----------
	    Mappa mappa = new Mappa((screenWidth / 8) - 55,(screenHeight / 8) -50,screenWidth / 3,screenHeight / 3);
	    Rectangle2D map = new Rectangle.Double(mappa.leftX(),mappa.topY(),mappa.width(),mappa.height());
	    g2.draw(map);
	    //--------CREO IL SERPENTE-------------
	    Snake snake = new Snake(10,10,(mappa.width() + 55) / 2,(mappa.height() + 50) / 2);
	    snake.Create_Snake(5,snake.testa(),(mappa.width() + 55) / 2,(mappa.height() + 50) / 2);
	    Nodo temp = snake.testa();
	    while (temp.succ() != null)
	    {
	        Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
	        g2.draw(rect);
	        temp = temp.succ();
	    }
	    //----------Disegno Le palline------
	    Ball ball = new Ball(10,10);
	    ball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3);
	    Rectangle2D bal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height());
		g2.setPaint(Color.RED);
		g2.fill(bal);
		g2.draw(bal);
 //-------------------INIZIO IL GIOCO-------------------
       
		
		
		
	}
	
/*	private abstract class keyHandler implements KeyListener
	{
	    public void keyPressed (KeyEvent event)
	    {
	        int keyCode = event.getKeyCode();
	        if (keyCode == KeyEvent.VK_RIGHT)
	        System.out.println("hai premuto il tasto right");
	    }
	} */  
}

[3nigma666]

La classe Panel è stata cosi implementa in maniera e sembra funzionare ,sia la logica del serpente ke gli eventi. C'è pero un altro prblemino. IL serpente si muove troppo velocemente perke l'occhio umano possa percepire il movimento,per questo volevo sapere se esiste in java un similare della funzione delay(value) ... vi prego non ditemi ke bisogna per forza usare i Thread ! vi posto il codice della classe Panels cosi vedete dove andrebbe implementato.
grazie dell aiuto

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;

public class Panels extends JPanel implements KeyListener
{
  public int keyCode;
  int i =0;
  int j = 0;
   public Panels()
   {
       addKeyListener(this);  // registrazione del listener
       setFocusable(true);
        // ...  
      
   }
    /* implementazione del listener */
    public void keyPressed (KeyEvent event)  { 
        keyCode = event.getKeyCode(); 
        System.out.println("valore"+keyCode);
    } 
    public void keyTyped(KeyEvent e) { }
    public void keyReleased(KeyEvent e) { }

    public void paintComponent(Graphics g)
    { 
        super.paintComponent(g);
    //-----------------INIZIALIZZAZIONE AREA DI GIOCO-----------------
        Toolkit kit = Toolkit.getDefaultToolkit();
        Dimension screenSize = kit.getScreenSize();
        int screenHeight = screenSize.height;
        int screenWidth = screenSize.width;
        Graphics2D g2 = (Graphics2D) g;
        g2.drawString("SNAKE Beta Vers. 0.01 Valerio Bignardi",20,20);
        //--------CREO LA MAPPA-----------
        int map_leftX  =(screenWidth  / 8) -55;
        int map_topY   =(screenHeight / 8) -50;
        int map_width  = screenWidth  / 3;
        int map_height = screenHeight / 3;
        Mappa mappa = new Mappa(map_leftX,map_topY,map_width,map_height);
        Rectangle2D map = new Rectangle.Double(mappa.leftX(),mappa.topY(),mappa.width(),mappa.height());
        g2.draw(map);
        //--------CREO IL SERPENTE-------------
        int S_width = 10;
        int S_height = 10;
        int S_leftX = screenWidth / 4 - 30;
        int S_topY = screenHeight / 4 - 40;
        Snake snake = new Snake(S_width,S_height,S_leftX,S_topY);
        snake.Create_Snake(5,snake.testa(),S_leftX,S_topY);
        System.out.println("Coordinate prima di Disegnare leftX:"+ snake.testa().leftX() +" topY: "+snake.testa().topY());
        Nodo temp = snake.testa();
        while (temp.succ() != null)
        {
            Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
            System.out.println("Coordinata disegnata leftX: "+temp.leftX()+" TopY "+ temp.topY());
            g2.draw(rect);
            temp = temp.succ();
        }
        //----------Disegno Le palline------
        Ball ball = new Ball(10,10);
        ball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3);
        Rectangle2D bal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height());
        g2.setPaint(Color.RED);
        g2.fill(bal);
        g2.draw(bal);
 //-------------------INIZIO IL GIOCO-------------------
       
        switch (keyCode){
            case KeyEvent.VK_UP    : //System.out.println("sono nel case UP");
                                    
                                     System.out.println("Coordinate prima del movimento");
                                     while (temp.succ() != null)
                                     {
                                       //  System.out.println("coordinata Nodo "+i+" leftX :"+temp.leftX());
                                       //  System.out.println("coordinata Nodo "+i+" topY :"+temp.topY());
                                         temp = temp.succ();
                                     }    
                                         
                                     
                                        temp = snake.moveto(1,snake);
                                        snake.C_testa(temp);
                                        i++;
                                        System.out.println("Coordinate dopo il movimento numero "+i);
                                        while (temp.succ() != null)
                                        {
                                            Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
                                            g2.setPaint(Color.BLACK);
                                            g2.draw(rect);
                                            repaint(0,0,800,600);
                                            j++;
                                            //Informazioni di Debug da eliminare
                                            System.out.println("coordinata Nodo "+j+" leftX :"+temp.leftX());
                                            System.out.println("coordinata Nodo "+j+" topY :"+temp.topY());
                                           
                                            temp = temp.succ();
                                            //contatore per Debug interno: da eliminare
                                            if (temp.succ() == null)
                                            j = 0;
                                        } 
                                  
                                        
                                     break;
            case KeyEvent.VK_DOWN  : System.out.println("Sono nel case Down");
                                     
                                     break;
            case KeyEvent.VK_LEFT  : System.out.println("Sono nel case Left");
                                     
                                     break;
            case KeyEvent.VK_RIGHT : System.out.println("Sono nel case Right");
                                     
                                     break;
        }
    
        
    }
    
}

3NiGm@666