Newsgroup: it.comp.java
Titolo: animazione

Ciao a tutti,
Sto realizzando una piccola animazione in java che dovrà poi essere in
grado di ricevere interazioni dall'utente.. doveva essere banale ma
sto incontrando diversi problemi ed in particolare nell'implementare
una raffica di oggetti ellipse2d che vengono sganciati sequenzialmente
da un velivolo.
Sono riuscito ad ottenere che impostando un valore intero che
rappresenti il numero di oggetti che devono essere "sparati in
raffica" questi vengono per così dire "gettati" tutti insieme
ottenendo l'effetto di un unico oggetto composto dalla sovrapposizione
di tot ellipse2d disegnate appunto uno sopra l'altra.
Quindi il problema e' nelle coordinate! Il fatto è che gli oggetti
devono partire da coordinate ricavate ad un tempo t. (in quanto il
velivolo e' in movimento) Sto usando un timer per implementare un
thread e per gestire il tempo.
Questi vengono sganciati al click di un Jbutton quindi nel suo
actionlistener ho abilitato il moto con determinate caratteristiche
(ad esempio la caduta sotto effetto gravitazione), ma l'evento
intercetta solo un punto (x,y) per tutti gli oggetti perche'
sovrapposti. Come sequenzializzare il tutto in modo che il primo
oggetto creato venga sganciato per primo, poi il secondo, poi il
terzo, ecc... ?
Gli oggetti una volta creati vengono inseriti in un vector uno per
volta. Poi dal vector vengono prelevati e disegnati.
--
Non ho mai programmato in Java ma ecco il codice... (scusate per la
lunghezza, ho cercato di ridurlo allo stretto necessario)
class animation extends JPanel implements ActionListener,
ChangeListener {
     private static Vector<Object> vector = new Vector<Object>();
     private BufferedImage bimg;
     protected boolean doTranslate = true;
     protected boolean doEuler = false;
     private int numShapes = 0;
     int period;
     protected double x = Math.random() * 1024;
     protected double y = Math.random() * 768;
  // definizione segnale sincronismo
  Timer timer;
  public animation() {
      setBackground(Color.CYAN);
      // initializes numbers of Strings, Images and Shapes
      setShapes();
      setBombs(5);
  }
//adds Shapes to a Vector
  public void setBombs(int num) {
      if (num < numShapes) {
          Vector<Object> v = new Vector<Object>(vector.size());
          for (int i = 0; i < vector.size(); i++) {
              if (((ObjectData) vector.get(i)).object instanceof
Shape) {
                  v.addElement(vector.get(i));
              }
          }
          vector.removeAll(v);
          v.setSize(num);
          vector.addAll(v);
      } else {						// ho diminuito il numero di bombe
          Dimension d = getSize();
          for (int i = numShapes; i < num; i++) {
              Object obj = null;
                  obj = new Ellipse2D.Double();
              ObjectData od = new ObjectData(obj);
              od.reset(d.width, d.height, this);
              vector.addElement(od);
          }
      }
      numShapes = num;
  }
  // calls ObjectData.reset for each item in vector
  public void reset(int w, int h) {
      for (int i = 0; i < vector.size(); i++) {
          ((ObjectData) vector.get(i)).reset(w, h, this);
      }
  }
  // calls ObjectData.step for each item in vector
  public void step(int w, int h) {
      for (int i = 0; i < vector.size(); i++) {
          ((ObjectData) vector.get(i)).step(w, h, this);
      }
  }
  public void drawDemo(int w, int h, Graphics2D g2) {
      for (int i = 0; i < vector.size(); i++) {
          ObjectData od = (ObjectData) vector.get(i);
          g2.setTransform(
od.at
);
          g2.draw((Shape) od.object); // or draw
      }
  }
  public Graphics2D createGraphics2D(int w, int h) {
      Graphics2D g2 = null;
      if (bimg == null || bimg.getWidth() != w || bimg.getHeight() !=
h) {
          bimg = (BufferedImage) createImage(w, h);
          reset(w, h);
      }
      g2 = bimg.createGraphics();
      g2.setBackground(getBackground());
      g2.clearRect(0, 0, w, h);
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                          RenderingHints.VALUE_ANTIALIAS_ON);
      g2.setRenderingHint(RenderingHints.KEY_RENDERING,
                          RenderingHints.VALUE_RENDER_QUALITY);
      return g2;
  }
  public void paint(Graphics g) {
      Dimension d = getSize();
      step(d.width, d.height);
      Graphics2D g2 = createGraphics2D(d.width, d.height);
      drawDemo(d.width, d.height, g2);
      g2.dispose();
      g.drawImage(bimg, 0, 0, this);
  }
  static class ObjectData extends Object {
      Object object;
      double x, y;
      double ix = 9, iy = 0; //coefficienti di moto
      double dt = 0.1;
      double g = 9.80;// meter per sec**2
      AffineTransform at = new AffineTransform();
  // generates random transformation direction and factor
      public ObjectData(Object object) {
          this.object = object;
      }
  /*
       * generates random coordinate values for all objects
       * and generates random size values for shapes
       */
      public void reset(int w, int h, animation moto) {
    	  x = moto.x;
    	  y = moto.y;
        	  ((Ellipse2D) object).setFrameFromCenter(0, 0, 10, 10);
     }
	    /*
       * calculates new transformation factors for the
       * chosen transformation and the current direction
       */
      public void step(int w, int h, animation moto) {
          at.setToIdentity();
          at.translate(x, y);
          if (moto.doTranslate) {
                      x += ix;
                      if (x > w) {	// cozza parete destra
	                  x = w - 1;
	            	  ix = -w/128 - 1;
	              }
	              if (x < 0) {      // cozza parete sinistra
	            	  x = 0;
	            	  ix = w/128 + 1;
	              }
	     if (moto.doEuler && object instanceof Ellipse2D) {
	    	 y += iy * dt;
	         iy += g * dt;
	         x += ix * dt;
	     }
          }
      }
  } // End ObjectData class
public void actionPerformed(ActionEvent e) {
	repaint();
}
}

 volta. Poi dal vector vengono prelevati e disegnati.
Devi fare in modo che una volta che clicchi sul Jbutton per sganciarli 
questi vengano sganciati con un certo delay l'uno dall'altro se non vuoi 
che cascano tutti insieme.
In pratica:
1) clicchi il JButton, parte il primo oggetto, setti un delay
2) passato il delay, ricalcoli le coord. del velivolo e sganci il 
prossimo, setti il nuovo delay
3) goto 2) fino a che sono finiti gli oggetti.
Normalmente i problemi di questo genere non sono inerenti a Java in se' 
(o un qualsiasi altro linguaggio), ma sono problemi di logica del 
programma. La cosa migliore e' mettersi li con carta e penna e fare un 
po' di disegni, schizzi,... per capire cosa deve fare esattamente il 
programma, cosa deve essere visualizzato, in che ordine, come si devono 
spostare gli oggetti nel frame, ecc.
Ciao Jack
-- 
Eroi non si nasce, ti incastrano
- Jim Belushi