[java] - caricare cerchi oggetti Ellipse2D su righe e colonne

[XvOg1]

Come posso inserire degli oggetti tipo Graphics2D:

public void paintComponent(Graphics g){
       Graphics2D ogg = (Graphics2D) g;

       Ellipse2D.Double cerchio = new Ellipse2D.Double(0, 0, 100, 100);
       ogg.draw(cerchio);

che vengono passati ad un JFrame..


vorrei che mi venisse una cosa del tipo:

-------------------------------------------
O|O|O|O|O|O|O|O|O|O|O|O|
------------------------------------------
O|O|O|O|O|O|O|O|O|O|O|O|
------------------------------------------
O|O|O|O|O|O|O|O|O|O|O|O|
------------------------------------------

dove ongni O è un oggetto Ellipse2D.Double..cioè un cerchio..
non capisco come fare ad implementare una cosa del genere..

Chi mi da un dritta?

[andbin]

Originariamente inviato da XvOg1
non capisco come fare ad implementare una cosa del genere..

Prima dovresti spiegare bene cosa vuoi fare. È chiaro che con il codice postato di Ellipse2D.Double ne disegni solo 1 e con posizione/dimensione fissa.
Se ne vuoi di più devi stabilire dove/quando devono essere "calcolate" le posizioni/dimensioni di questi cerchi.

[XvOg1]

Praticamente stò cercando di modificare questo:
http://forum.html.it/forum/showthrea...readid=1218050

Siccome la parte testuale l'ho gestita tramite array bidimensionale di char ora vorrei capire come trasportare il tutto con palline colorate tramite interfaccia..penso che dato che gli oggetti Ellipse2D ricevono coordinate la matrice non ha più senso..quindi come gestire il tutto?? :master:

[andbin]

Originariamente inviato da XvOg1
penso che dato che gli oggetti Ellipse2D ricevono coordinate la matrice non ha più senso..

Sbagliato. Ti serve comunque una matrice specifica per tenere le informazioni sulle celle (se è vuota, se contiene una pallina e quale tipo). Anche perché a fronte di un click su una cella, devi andare a scansionare la matrice tramite un apposito algoritmo per cercare le eventuali celle adiacenti con la stessa pallina.

Poi nella fase di rendering è chiaro che si dovrà esaminare la matrice per sapere cosa/dove visualizzare qualcosa.

[XvOg1]

Originariamente inviato da andbin
Sbagliato. Ti serve comunque una matrice specifica per tenere le informazioni sulle celle (se è vuota, se contiene una pallina e quale tipo). Anche perché a fronte di un click su una cella, devi andare a scansionare la matrice tramite un apposito algoritmo per cercare le eventuali celle adiacenti con la stessa pallina.

Poi nella fase di rendering è chiaro che si dovrà esaminare la matrice per sapere cosa/dove visualizzare qualcosa.

Ok, mi serve una matrice, ma di che tipo? dello stesso tipo dell'oggetto che mi crea i cerchi?

gli algoritmi li ho già in mente a livello testuale..devo solo capire come inserire questi oggetti nella matrice..come associargli il colore ..

ad esempio, per impostare la griglia di gioco con pedine diverse utilizzavo un metodo con due for annidati:

public void impostaGriglia(){

 

	Random generatore = new Random();

	char[] pedine = {'@','*','X','O','%','&','$','#'};

	  

          for(int i = 0; i < l ; i++)

        	  for(int j = 0; j < h; j++){

        		  int c = generatore.nextInt(t);

        		  campo[i][j] =  pedine[c];

	     }

   }

ora al posto dei caratteri come faccio ad impostargli un cerchio di quel tipo?? :master:

[andbin]

Ecco un esempio:

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

public class SameGameFrame extends JFrame
{
    private SameGameBoard board;

    public SameGameFrame ()
    {
        super ("Same Game");

        setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);

        board = new SameGameBoard (5, 10, 32);
        board.initRandom ();

        Container contentPane = getContentPane ();

        contentPane.add (board);
        pack ();
    }

    public static void main (String[] args)
    {
        SwingUtilities.invokeLater (new Runnable ()
        {
            public void run ()
            {
                SameGameFrame f = new SameGameFrame ();
                f.setVisible (true);
            }
        });
    }
}

class SameGameBoard extends JPanel
{
    public static final byte EMPTY = 0;
    public static final byte RED = 1;
    public static final byte GREEN = 2;
    public static final byte BLUE = 3;

    private int rows;
    private int columns;
    private int cellSize;
    private byte[][] board;
    private Dimension dim;

    public SameGameBoard (int rows, int columns, int cellSize)
    {
        this.rows = rows;
        this.columns = columns;
        this.cellSize = cellSize;
        board = new byte[rows][columns];
        dim = new Dimension (columns * cellSize, rows * cellSize);
    }

    public void initRandom ()
    {
        Random rnd = new Random ();

        for (int r = 0; r < rows; r++)
        {
            for (int c = 0; c < columns; c++)
            {
                board[r][c] = (byte) (rnd.nextInt (3) + 1);
            }
        }

        repaint ();
    }

    public Dimension getPreferredSize ()
    {
        return dim;
    }

    protected void paintComponent (Graphics g)
    {
        super.paintComponent (g);

        Color oldColor = g.getColor ();

        for (int r = 0; r < rows; r++)
        {
            for (int c = 0; c < columns; c++)
            {
                int y = r * cellSize;
                int x = c * cellSize;

                g.setColor (Color.WHITE);
                g.fillRect (x, y, cellSize, cellSize);

                switch (board[r][c])
                {
                    case RED:
                         g.setColor (Color.RED);
                         g.fillOval (x, y, cellSize, cellSize);
                         break;
                    case GREEN:
                         g.setColor (Color.GREEN);
                         g.fillOval (x, y, cellSize, cellSize);
                         break;
                    case BLUE:
                         g.setColor (Color.BLUE);
                         g.fillOval (x, y, cellSize, cellSize);
                         break;
                }
            }
        }

        g.setColor (oldColor);
    }
}

L'ho scritto velocemente quindi non è certo il massimo della efficienza/bellezza. Ma è davvero molto semplice e lineare. Come puoi vedere non sono cose difficili da fare. Basta solo sfruttare ciò che Java mette a disposizione. Quindi basta usare "bene" array, cicli e un pizzico di matematica basilare.

[XvOg1]

Grazie Andrea, vedrò di studiarmi bene i metodi e le classi che hai usato per gestire il tutto, anche perchè per ora molte cose mi sono nuove.
Ciao